There was no outage and no product. An architecture decision review board — a team submits a decision, the
architecture team rules on whether it fits enterprise architecture — had been in design for about two
years and never built. The process it was meant to replace lived in Confluence: wiki pages an admin
edited, process text a submitter read and interpreted.
There was real work behind the stall. A designer had gone through every screen with the team, and inside
Figma the result was genuinely good — each workflow with its steps, the options at each step, the
branching, every iteration visible. What they didn’t have was an engineer who would sit down and take all
that and build a site. The group on it was mostly not hands-on keyboard, and starting a project the
official way means a lot of paperwork. So they were stuck in analysis paralysis.
Two weeks, set by my sponsor, and the point of the exercise was the AI tooling. The stack wasn’t mine to
pick — I asked the team what they cared about before writing anything, because I wasn’t going to maintain
it. A dev AWS account: real infrastructure, not production.
Production was out of reach inside that window: the path to prod there takes six weeks at minimum. SSO
stayed out, since Okta groups meant red tape I didn’t want to spend the two weeks on. Keys for the
production model gateway were the enterprise AI team’s to issue, not mine. And it was me alone at the
keyboard the whole time.
Ask the team for the stack before writing a line. They wanted Node.js behind React, and
Postgres eventually. I built exactly that. Rejected: anything I’d have picked for myself. My mantra is
to get a team up and going, get them over the hump, train them on everything I did, and walk away — and
a handoff only holds if the thing is native to them.
SQLite behind a swappable data layer, not Postgres on day one. Postgres was available.
The size and volume of requests didn’t call for it, and backups are one file copy. The layer was
database-agnostic, so pointing it at their Postgres later was a configuration change. Schema versioning
was homegrown —
SQL scripts, a version check as the app starts, run whatever’s missing. Enterprise tools do this at scale; light and simple was the right size here.
Decompose the design myself and let the model fill the leaves.Whole pages didn’t work — the
model wasn’t strong enough to hold one. So: a screenshot of one component, build me a React component
that looks like this, repeated for every major component on the site, then a workflow’s steps as
screenshots, one workflow at a time, with a standing instruction to ask me any question it didn’t have
an answer to. It rebuilt components it already had unless told not to, so “reuse any previously built
components” went into every prompt. The agent wrote unit tests and drove Playwright against the UI as it
went. The design-to-code tools of that period — Figma Dev Mode, v0, Builder.io, Anima, Locofy — were not
part of this build. The standing independent complaint about that class is cleanup, imperfect component
reuse included — the hurdle on this side too.
Let the assistant drive the UI, not the API. My sponsor asked for an assistant inside
the platform, generic enough that it wouldn’t be rebuilt every time the site changed. Running inside
React, it could interrogate the page — the text, the buttons, the capabilities, the errors — and send
that along with the user’s request and their position in the flow. The model answered with formatted
JSON: a list of actions. The client clicked
and filled, then sent back what changed, new errors and new buttons, and the loop went again. It fits a
domain where the workflows branch on your answers: a hundred users takes a different path than ten
thousand, and clicking through screens you don’t know is tedious. The alternative — an agent calling the
backend API and skipping the screens — was never weighed against it. This was the ask, and the point was
to show the art of the possible.
Make it work first, then pay the debt — before the handoff. The model left a mix of
TypeScript and plain JavaScript, and naming conventions that didn’t match, which was frustrating. It
took many passes to make the codebase uniform: everything on TypeScript, test cases organized, the whole
thing reading as one piece of work. I don’t think it’s smart or safe to say we should build with AI and
have it perfect on the first shot. It’s iterative, the same as building by hand. The refactor pass paid
twice — it forced the agent to look at the same code through a different lens, and it saw things it
hadn’t seen while building.
Not again: don’t hand a team a codebase the model left half TypeScript and half
JavaScript — pay the debt while you still own it.
Most of the site was clicking through inside the first week: roughly two dozen components, seven or eight
workflows with their branches. I worked through the weekend, just because I was excited about the project.
Week two went to two things asked for on top of the Figma. The assistant was one. The other was
admin-editable text — a slug for every place text appears, stored in the database and rendered on load,
editable in place by an admin. That one was the smaller build and the easier sell, because it matched the
Confluence process it was replacing, where an admin edited the page and everyone downstream read the new
words.
The demo ran to about fifteen people: my boss, his boss, the architecture team, the design team that had
been working on it — and very few engineers among them. The assistant clicking buttons and filling fields
live is what landed.
After the demo they staffed the team. Engineers were put on it, the infrastructure got done, and they took
it through the six-week path to production themselves. It has been running about a year. No support
request has reached me, and no usage figure is published.
Week 1
Week 2
Weeks 3–8 (the team)
Who
Me, solo (through the weekend)
Me, solo
Engineers, staffed after the demo
Built
~2 dozen components, 7–8 branching workflows
The in-app assistant; admin-editable text, per-slug
Postgres swap; Okta against hooks I’d left in; production gateway keys; workflows of their own
Milestone
Site clicking through end to end
Demo to about 15 people
Shipped to prod; running about a year, no support request
The assistant survived the move to production. In the prototype it could press Submit on a decision, and I
don’t know whether the team kept that or limited it.
Today I wouldn’t leave Submit to the agent —
making it unable to press Submit is one line of code. The prototype showed the ceiling. Where the line
actually sits belongs to whoever owns the thing.
One project is not a measurement. I have no before-and-after on developer throughput here and I’m not
claiming a multiplier — what I stand behind is the wall clock: two years, then two weeks, then six.
Nothing got copy-pasted out of it. What carried was the shape: an engineer with AI tooling can take a
stalled project to something real without a funded team standing up around it first. In that organization,
getting anything done meant a fully funded team — product owner, developers, stakeholders, the whole set
of ceremonies. To get something out the door, what you really need is one person with the will and some AI
tooling to push it forward. Then the funded team owns it: two weeks produced the staffing that two years
of design review hadn’t.
The admin-edit feature is the piece the team says it likes. Non-developers change the wording without a
development cycle, which is what the wiki used to give them and the new platform would otherwise have
taken away.
The board ships by name — ADRB, the architecture decision review board — cleared for print, and so does
the client. My sponsor and the enterprise AI team that runs the model gateway appear as roles, not names.
No team names, no org chart, no ticket IDs. Head count in the demo room is rounded, and there is no usage
figure because I never had one. The model’s minor version is deliberately absent: my recollection is
Sonnet 3.5, and a check of what Cursor’s picker actually offered in Q2 2025 doesn’t settle it, so this
entry names the family and not the point release. Stack footnote: React, Node.js, TypeScript, SQLite
behind a swappable data layer, Amazon ECS, Cursor driving a Claude Sonnet model, the Vercel AI SDK against
an internal LiteLLM gateway, Playwright.
