The idea was simple.
The ambition was not.

What if anyone shaping a product had a small workshop of resident specialists — each brilliant at one part of the craft — sitting beside them as they work? Not a chatbot. Not an everything-tool. A few focused minds, each trained to think the way a senior practitioner thinks about their specific part of the work.

That's the kind of difference that doesn't come from a slicker UI. It comes from 25 years of lived experience baked into every prompt. The way Crit ranks severity isn't generic — it reflects the judgment calls a design director makes after seeing a thousand shipped products break in the same ways. The way Form decides between layout-first and component-first isn't a coin flip — it's the call a director would make in a real review.

Claude provides the intelligence. The intention comes from a quarter century of building products for real people.

March 14, 2026.
Everything starts.

The first commit lands at 10:49 AM. By noon, there's a monorepo, a database, authentication, and an API. By evening, the audit agent is alive. Streaming responses. Persisting to Postgres. Every thought traced.

Not a prototype. Not a mockup. A working product.

The next two weeks turn that first commit into a complete platform — workspace, dashboard, sidebar, project navigation, billing, credits. Five named agents, each shipping with structured output and cross-agent handoffs. A dark UI, every pixel considered.

Fourteen days. Five agents. Zero shortcuts.

Five names
became three.

The first version had a roster of five: Mine, Frame, Plot, Crit, Tone. On paper, neat. In use, blurry. Some agents kept overlapping. Some had jobs that didn't repeat often enough to feel like a craft. The workshop was too crowded for the room.

So the casting changed. Three agents, each with a verb. Each one a builder — not a chat partner.

Three is the right shape for the work most teams actually do: find what's wrong, decide what to do about it, build it.

Day eleven.
The hard look.

A UX audit on day 11 surfaced something uncomfortable: the app was feature-rich but designed around what the system could do, not what the person was trying to accomplish. Seven clicks before first value. Mode toggles that exposed the architecture. A dashboard that asked the user to be the system administrator of their own creative work.

The highest-impact fix transforms the agent from a black box into a collaborator. — from the day-11 audit

So the toolbar disappeared. Mode selection became automatic. Project history moved inline. Post-run nudges began guiding the user to the natural next step. The suggested agent's tab started to glow when it was its turn.

The app didn't gain features. It became more thoughtful.

The handoff
that finally carried context.

For weeks, the handoff worked like a sleight of hand. When you finished a Crit run and clicked Send to Form, a small chip appeared above the input that read "Using crit-2026-05-10.md." It looked considerate. It was a lie.

The Crit report wasn't actually being sent to Form. The chip was a label, not a payload. Form, predictably, kept asking "I don't see the Crit report you mentioned" — which sent the user into a fugue of double-checking.

Fixing this was a turning point. The receiving agent now sees the source agent's full output, attached as a real reference. The handoff carries the actual context, not the suggestion of it. The loop opens both ways: Form can send back to Crit for a re-audit. Forge can ask Form for a refinement before it builds. The agents stopped being three islands and started being one workshop.

Forge was named
for what it does.

The first Forge prompts had it writing code reviews. Severity ticks. Findings. The kind of output you'd hand a senior reviewer on a PR. It was good work. It was also the wrong work.

I never asked for Forge to be a reviewer. It was always build. Even the name suggests that. — the user, gently correcting the brief

The three prompts were rewritten that afternoon. New output schema: a plan paragraph (server vs client, file count, data shape), then one fenced code block per file with the path as the heading, then drop-in notes (install these, place them here), then "still open" — design decisions the brief left silent that Forge picked a defensible default for. Then a single line: "Next pass?"

Forge now does the thing its name promises. Design comes in. Working code comes out.

Outputs that fit
where the work lives.

The next honest move was admitting that keya isn't where the work ships. Code ships in your repo. Designs ship in Figma. A bigger build ships through Claude Code or a team of engineers. keya is where the work gets sharpened — and the artifact has to fit the next stop in your kit.

So the lenses split. Forge's React/Next.js lens writes drop-in code, each file downloadable, the whole set bundled as a zip. Its Implementation plan lens writes a phased Markdown plan with a file map, type contracts at module boundaries, and check-boxable acceptance criteria — ready to paste into Claude Code. Form's Figma brief lens emits a structured spec — frames, type scale, color tokens, components, motion — pasteable into Figma Make or shareable with a designer who works in your house style.

Three handoff shapes, because there are three places work actually goes. You pick the one that fits Monday morning.

Anchor it once.
The agents remember.

Every project carries an anchor — a screenshot, a URL, a PDF, a short brief. You drop it once when you start something, or edit it later from a small gear icon next to the project name. From then on, every Crit, every Form, every Forge run sees it. The agents never make you re-explain the work.

The other thing that quietly accumulates is craft. Every run earns KP — a few points for Crit, more for Form, more again for Forge. Per user, not per project. The bar in the sidebar fills as you work and slowly steps you through rank: Apprentice → Practitioner → Craftsperson → Artisan → Principal → Fellow. No streaks, no badges, no confetti. Just a quiet ledger of work done.

What it's built on.

Modern, boring, legible. Next.js App Router with Server Components by default. Claude Opus 4.x via the Vercel AI SDK. Drizzle ORM against Neon Postgres for the data, Vercel Blob for the files, Clerk for auth. TypeScript strict throughout. Tailwind for styling. No CSS-in-JS runtimes. No magic.