Pin

Inspiration

Humans are bad at saying what they want. Ask a doctor to describe a symptom, a lawyer to draft a clause, a founder to write a cold email, a developer to prompt a coding agent. The hard part is never the execution. It's the specification.

Execution is getting cheaper every month. Claude writes the code. Cursor closes the tickets. Agents schedule meetings, file expenses, draft contracts. The bottleneck has moved. In the age of automated agents, the person who can specify better wins. Prompts are the new goldmine.

But prompting has a tax. The gap between what you want and the words that get it to you is real cognitive work. Skilled users pay the tax fluently. Everyone else bounces off the blank chat box.

We asked: can we remove the tax? Not "make prompts easier." Remove them.

What it does

Pin is a writing tool where you never write a prompt.

Answer three tiny questions. Audience, feel, shape. Three drafts stream in at once, in three different voices: direct, warm, vivid. You tap the sentences you like. The model rewrites around your pinned sentences verbatim, bridging between them in the voice you chose. Done.

• No prompt engineering. You see, you pick, you refine.
• No blank page. Three drafts appear in parallel, about 15 seconds.
• Ambient suggestion. A cheap model scores every sentence for pin-worthiness. High-scoring sentences get a subtle tint and a ✦ marker so your eye lands there first.
• Intent graph. A right-drawer timeline shows how the final piece was assembled: which interview answers, which pins came from which columns, what each regeneration did.
• Manual override. Textarea edit mode for tweaks the model can't make.
• Export. Copy as markdown or send via email.

Novices reach expert output by pointing. Experts reach the same output in the same time, just with more pins.

How we built it

Stack. Next.js 15 + React + TypeScript. Anthropic SDK with streaming. Deployed on Vercel.

Models. Sonnet 4.6 for the three parallel drafts and the pin-anchored regeneration (highest craft, worth the tokens). Haiku 4.5 for the three divergent openers, pin-worthiness scoring, and eval-harness judging (fast, cheap, runs inside every user session).

The architecture decision that mattered. We originally planned Tiptap with custom sentence-ID decorations. First-principles reasoning flipped us to snapshot + pin-array: each draft is an immutable string, sentences are split client-side with Intl.Segmenter, pins are plain strings stored in React state. No contenteditable, no ID migration across regenerations. Saved six hours.

Draft diversity. Three concurrent LLM calls on the same topic regress to the mean. We solved it with forced divergent openers: one Haiku call generates three opening sentences in different angles; each is fed as the fixed first line of a separate Sonnet stream. Spike passed 15/15 pairs at Jaccard ≤ 0.45.

Pin-anchored regeneration. Strict system-prompt rules telling the model to include every ANCHOR n sentence word-for-word and bridge between them. Spike passed 15/15 on verbatim preservation.

Sentence chunking. Raw Intl.Segmenter creates one-word card spam ("Hey." "Wild."). Built a greedy chunker that merges adjacent sentences until each card hits ≥12 words, never splits inside a sentence.

Design. Warm off-white background, Source Serif for the prose, Inter for chrome, one accent color (burnt orange). No cards-in-colored-circles, no 3-column feature grid trap, no gradient backgrounds. Typographic confidence first.

Process. We ran the full gstack plan cycle before writing code: office hours → CEO review → eng review → design review. Two 30-minute spikes validated the load-bearing assumptions. Then 30 minutes of build to demoable.

Challenges we ran into

• Draft diversity. Three parallel LLM calls on the same scenario produce nearly identical prose unless you force divergence. The divergent-openers strategy was the fix; we killed the "three voices as system prompts" approach after the spike.
• Verbatim anchor preservation. Getting Sonnet to include a pinned sentence exactly, with the same punctuation and capitalization, was surprisingly reliable once we wrote the rules as inviolable constraints. 15/15 on the spike.
• Streaming into card layouts. Token chunks arrive mid-word. Sentence boundaries shift as the text completes. We had to render chunks on every token update without flickering or losing click targets.
• Resend sandbox. Email export broke at first because RESEND_FROM pointed at an unverified domain. Moved to Resend's sandbox sender and surfaced the actual Resend error to the user through a persistent banner, so failures explain themselves.
• Pin matching across regeneration. A pinned chunk can end up inside a slightly different sentence boundary after regeneration. We made pin-matching tolerant of substring containment so highlighting stays consistent.

Accomplishments that we're proud of

• Both load-bearing spikes passed 15/15 before we wrote any UI.
• Novice and expert finish the same 200-word piece in under 90 seconds, with LLM-judged quality within 0.5 points on a 10-point rubric.
• We built the entire product, end to end, with zero prompts typed by the user in the happy path.
• Intent graph turns an invisible model-of-user-intent into a shareable artifact.
• Design language holds its own. Zero AI-template slop. A writer would trust the interface.
• Shipped in hours because we planned in minutes.

What we learned

Pointing beats typing. Describing what you want is hard. Choosing what you like is easy. When the interaction primitive flips from author to choose, the articulation tax drops to near zero. Pin is a gesture, not a feature.

First-principles beat defaults. The default architecture (Tiptap, stable IDs, contenteditable) was wrong for a product where users never free-edit. A six-hour shortcut was hiding in plain sight. Always ask whether the conventional stack is actually the right stack for your specific interaction.

Spikes before UI. Proving draft diversity and anchor preservation in 30 minutes saved us from building the whole product on two assumptions that could have quietly failed in the demo.

Cheap models, everywhere. Haiku is fast enough to run inside the UI loop (scoring, opener generation) without the user noticing. Sonnet stays for the craft-heavy calls. Two-tier model usage is the right default, not an optimization.

What's next for Pin

The wedge we just shipped: short-form writing. Cold emails, chapter openings, condolence notes, cease-and-desist letters, post announcements, manager updates. Enough to get usage and signal.

Near-term:

• Voice-to-pin. Long-press a pin, say "but angrier" or "shorter." The model rewrites that anchor only. Even lower articulation cost.
• Mobile layout. Adaptive UX so the 3-column moment still lands on phones.
• Chat integrations. WhatsApp, Telegram, Signal, Discord, Slack bots that reply with 3-pin drafts. Pin replies go inline.

New domains: the pin gesture generalizes.

• Image generation and edits. Three variants, pin the regions or elements you like, regenerate around them. Kills most of the back-and-forth in today's generative image tools.
• Data query and analysis. Three proposed analyses on your CSV, pin the columns, filters, or charts that fit, regenerate a dashboard around them.
• Creative writing at length. Scale to chapters. Pin sentences across drafts; the model carries your pinned voice forward.
• Task and workflow automation. Agents propose three possible plans, user pins the steps they want, agent executes around the pins.

The long bet.

Built With

• anthropic
• next.js
• react
• sdk
• typescript.