# How to Vibecode Superhuman — Can You Do It Yourself?

> Docs, Mail, and AI That Work Everywhere

- Site: https://superhuman.com
- Category: Productivity Suite
- Verdict: **Don't bother** (12/100 vibecodeable)
- Estimated effort: 6+ months of full-time work

## Verdict

Build a basic markdown note-taking app with a local LLM wrapper instead, because cloning a unified enterprise productivity suite spanning email sync, CRDT document collaboration, and browser-wide automation requires multi-year team engineering.

Attempting to clone Superhuman as a solo developer is a trap. You will hit a brick wall immediately on the email sync engine—handling IMAP IDLE, OAuth token refreshes for millions of users, and local offline caching reliably will consume months of debugging. Furthermore, building a real-time collaborative document editor with formula engines and blocks requires complex CRDT conflict resolution. If you want a personal workspace, build a simple markdown editor with local AI integration; attempting the full suite is a recipe for endless frustration.

### What you can't replicate

- Enterprise trust, compliance, and SOC 2 Type II audit history
- Ecosystem integrations across over 1 million external apps and websites
- Massive network effects of 40 million daily active users

## What it does

An AI-native productivity suite combining Superhuman Mail, Superhuman Docs (formerly Coda), Grammarly writing assistance, and Superhuman Go cross-platform workflow automation.

### Core features

- Real-time collaborative document editor with blocks and tables
- Keyboard-driven IMAP/SMTP email client interface
- AI text rewriting and grammar correction middleware
- Multi-account inbox synchronization and caching
- Cross-application AI chat sidebar and context ingestion
- Relational table formulas and basic automation triggers

## The business

### Pricing

- Free: $0 — Basic access to AI chat, writing assistance, and docs.
- Pro: $15/mo — For individual power users.
- Business: $40/mo — For teams requiring email and deeper sync.
- Enterprise: Custom — For organizations requiring advanced security.

### Funding

$1B+ raised.
- Series unknown (Grammarly $200M in 2021)
- General Catalyst $1B financing (2025)
Investors: General Catalyst, IVP, Spark Capital, General Atlantic

Founded 2009.
Team size: 1,500+.

## The hard parts

- Rebuilding high-performance email IMAP/SMTP sync and local SQLite caching layers
- Implementing real-time collaborative editing using CRDTs or operational transformation
- Building a browser extension or cross-app automation engine that safely scrapes and injects into DOM elements
- Managing OAuth token lifecycles across thousands of external Google and Microsoft accounts without rate limit failures

## How to vibecode Superhuman

### Prerequisites

- Node.js (free): Required runtime for executing the full-stack TypeScript project.
- GitHub (free): Version control and CI/CD deployment pipelines.
- Google Developer Account (free): Required to configure OAuth credentials for testing Gmail sync.

### Recommended AI tools

- Claude Code: Autonomous terminal coding agent capable of scaffolding multi-file web applications and debugging complex state logic.
- Cursor: AI-native code editor for reviewing diffs and making fine-grained UI adjustments.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js API routes / Node.js backend
- Database: Supabase (PostgreSQL)
- Auth: Supabase Auth
- Payments: Stripe
- Other: TipTap / Prosemirror for document editing, OpenAI SDK for AI text features

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API functions): $0-20/mo
- Supabase (PostgreSQL database and user authentication storage): $0-25/mo

### Build guide

1. **Project Scaffolding and Authentication Setup** — Initialize the Next.js project with Tailwind CSS, configure Supabase Auth for email and password login, and set up the main layout shell with a sidebar navigation mimicking the Superhuman suite dashboard.

```
Create a new Next.js project using TypeScript and Tailwind CSS. Integrate shadcn/ui component primitives. Set up Supabase authentication client utilities for user sign-up and login. Build a clean dashboard layout with a collapsible sidebar containing links for 'Mail', 'Docs', and 'Settings'. Ensure responsive design and clean dark-mode styling.
```

2. **Document Workspace Core (Subset of Docs)** — Build a block-based document editor interface supporting titles, headings, bullet lists, and basic markdown formatting stored in Supabase PostgreSQL.

```
Build a document workspace view using TipTap or a lightweight block-based editor component in Next.js. Create a database schema in Supabase with tables for `workspaces`, `documents` (with id, user_id, title, content json, updated_at), and implement real-time saving. Add a sidebar list to create, view, rename, and delete documents.
```

3. **AI Writing Assistant Integration** — Connect an OpenAI or Anthropic API endpoint to provide text rewriting, tone adjustments, and grammar correction directly inside the document editor.

```
Implement an AI writing assistant backend route using the official OpenAI or Anthropic SDK. Add a floating toolbar action in the document editor that lets users highlight text and select commands such as 'Make professional', 'Shorten', or 'Fix grammar'. Stream the response back to replace or append the selected text inline.
```

4. **Email Client Shell and IMAP Mock Integration** — Create a keyboard-shortcut-driven mail client interface with split inbox views, list navigation, and simulated message threads.

```
Build a keyboard-shortcut-driven email client interface in Next.js. Create views for 'Important', 'Other', and 'Archive'. Implement keyboard event listeners for quick navigation (e.g. 'j' and 'k' to move up and down, 'e' to archive, 'r' to reply). Populate with mock email thread data stored in Supabase with fields for sender, subject, body, read status, and labels.
```

5. **AI Inbox Triage and Summarization** — Add AI summary and automated drafting capabilities to the email client view to parse thread history and generate draft replies.

```
Add an 'AI Actions' menu to the email view. Implement a backend action that takes selected email thread messages, sends them to an LLM with a prompt to summarize key action items, and generates a polite response draft matching the user's selected tone. Display the draft in a modal for user confirmation before saving.
```

6. **Polish, Error Handling, and Deployment** — Refine keyboard shortcuts, handle loading and error states gracefully, and deploy the application to Vercel.

```
Conduct a thorough code review across all pages. Add comprehensive error boundaries, toast notifications for successful actions (e.g. 'Document saved', 'Email sent'), and loading skeletons. Prepare environment variable configurations and configure deployment on Vercel.
```

### Cost vs paying

**Starting costs (one-time):**

- Custom domain registration: $12/yr
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- AI coding tool subscription: $20/mo
- Hosting and database (Supabase/Vercel): $0-25/mo
- Total: ~$20-45/mo

- Paying for the SaaS instead: $40/mo (Business tier)
- Build time: 120-160 hours
- AI tool credits: $20/mo (Claude Pro or Cursor Pro)
- Break-even: Never (purely for personal learning)

## Sources

- [Superhuman Official Homepage](https://superhuman.com)
- [Superhuman Pricing and Plan Matrix](https://superhuman.com/pricing)