Nov 22, 2026
12 Views
0 0

Prototypes have always been the most effective specification-especially with AI

Written by
A working prototype open on a laptop in a meeting room, the printed requirements document still closed beside it.

Prototypes have always been the most effective specification—especially with AI

When building a working version costs an afternoon, the artifact that used to precede the work now falls out of it instead.

Somebody on your team has a working version of the feature, and the requirements review is still three days out. They built it between meetings and did not mention it, because the plan said write the requirements, get sign-off, then build.

Then it lands in Slack and the room changes.

Three open questions in the document answer themselves once you can click the thing, and two more turn out to be the wrong ones.

Most teams would call that working backwards.

I have watched it often enough to stop calling it a failure, because the document written afterward beats the one that would have come first.

Who built it matters less now and we have to accept that.

Deisgners are getting it — use AI.
Deisgners are getting it — use AI. State of Prototyping surveu by UX Tools.

That somebody might be a product manager, a designer, or an engineer, and all three can do it in an afternoon.

We all have to get comfortable with anyone producing the prototype, because that is what this new world has enabled, and there is no way to stop it.

The specification did not become useless when building got cheap. It changed position in the sequence, which gave it a new job: from a prediction about a system nobody had touched to a record of what building it settled.

Trace Why Specifications Exist

The specification is a cost artifact. It exists because building was expensive and writing about it was cheap, so teams bought certainty in the cheap medium before spending in the expensive one. The rituals follow from that trade: the sign-off, the change request, the version number on the cover page.

I once wrote a 1,200-page specification, and it was a waste of my time.

Writing was never a description of the system. It was the cheapest available simulation of building one.

In his 1986 essay No Silver Bullet, Fred Brooks argued that the hardest part of building software is deciding what to build. In his view, clients do not know what they want until they have seen a version running.

His fix was rapid prototyping at a moment when prototyping still cost real money, so most teams nodded and kept writing requirements.

The person writing them holds a model of the system in their head and cannot un-know it, which my reference site files under the Curse of Knowledge. I have run rapid prototyping with my own teams at multiple companies, and it has been very, very effective.

A prototype gets that model out of one head and onto a screen everyone can test.

Prototype Before the Review

What changed is not the argument, it is the price of the alternative.

Eric Ries gave the idea a cycle in 2011 with The Lean Startup: build, measure, learn, and repeat. He and Brooks both assumed building was the slow step.

Lean Startup — My favorite process, ever.
Lean Startup — My favorite process, ever. Build what you know, then iterate and research after.

UX Tools surveyed 1,478 self-selected designers for State of Prototyping: Spring 2026, and 59.1 percent had built their own tool, application, or utility with artificial intelligence in the previous six months. That number describes what one designer can put in front of a room by Thursday.

A prototype does not win arguments. It ends them, by turning a disagreement about a hypothetical into an observation about a thing.

The questions a requirements document handles worst, like behavior under load or the fourth step of a flow, are cheap to answer and costly to guess. Enterprise software is a good place to start iterating, because most of its design patterns are solved.

Tables, filters, forms, approvals, and permissions have been worked over for decades, and systems like Carbon, which calls itself an “enterprise-ready, open-source design system,” write them down as components.

A prototype built from those parts looks credible on the first afternoon, which saves the iteration for the workflow no library covers.

Run Research Every Week

A working version also changes what research is for. Discovery used to be a phase: interviews before the requirements, a study before launch, and a long quiet stretch between. When a team can build something new every few days, each build raises a question nobody had last week, and a study that wrapped in March cannot answer it.

Discovery stops being a phase you finish. It is always on, because every build asks a new question.

Teresa Torres has argued for that cadence. Her definition of continuous discovery calls for “weekly touch points with customers by the team building the product,” run in pursuit of a desired outcome.

Cheap prototypes give those sessions something to react to instead of a description to imagine.

Stakeholders reading requirements argue about what a user would do, while participants in front of a prototype simply do it. The researcher’s job shifts from running a study to keeping that loop honest: choosing which build meets which people, and saying out loud when the team is mostly testing its own enthusiasm.

The RITE Method — Simple but effective.

Use the RITE Method

Usability testing went through this inversion once already. In 2002, Michael Medlock and colleagues at Microsoft described Rapid Iterative Testing and Evaluation in Using the RITE method to improve products; a definition and a case study.

A classic study runs every participant, then writes a report. RITE changes the interface “as soon as a problem is identified and a solution is clear,” sometimes after a single participant.

RITE stopped waiting for the full study, the way cheap builds now stop waiting for the full specification.

On the Age of Empires II tutorial, the team changed the design after six of its first ten participants and fixed 30 of the 31 problems it found.

One condition carried the method: the development team’s decision makers had to take part, which the paper calls “more than a commitment to attend and review.” That is the room this article keeps describing, with the user finally in it.

Small samples were never the weak point: Jakob Nielsen argued in 2000’s Why You Only Need to Test with 5 Users that five participants surface roughly 85 percent of usability problems, a figure researchers still debate. Put a build in front of five people on Monday, fix it between sessions, and the specification you write Friday describes behavior you watched.

A prototype I built with Lovable where the specifications were written by the tool from the prototype. That was a year and a half ago, and now the specifications are so much better. You can play with the prototype here.

Write the Specification Last

So write the specification, and write it second. While the team iterates, the prototype is the working document: the thing people edit, review, and point at.

It is also the source of truth.

When the prototype and a paragraph disagree, the prototype wins, because it is the one somebody tested.

The specification becomes the account of how the prototype got that way, and its author has stopped guessing. It records which approach was tried, what broke, and why the surviving option won. That is closer to what Jeff Jeff Gothelf and Josh Seiden asked for in Lean UX, which steers teams toward the product experience rather than deliverables.

More people can build that working version than two years ago. Figma’s 2026 AI Report, drawn from 8,403 survey responses, found the share of designers participating in development doubled to 41 percent, while developers doing design work rose from 44 to 60 percent. As that line thins, the prototype stops belonging to one role and becomes the team’s shared working document.

A specification written before the build is a forecast. One written after is a record of decisions somebody already tested.

Writing the account no longer starts from a blank page either. Cursor’s Generating Documentation with Cursor says it “reads your code and generates documentation that reflects what the code does,” design documents and architecture overviews included.

Claude Code’s Common workflows guide suggests asking it to “explain the main architecture patterns used here” and “what are the key data models?” The specification can come out of the same tool that built the prototype, with a person editing in the decisions the code cannot explain.

For features built on a model, evals are the new specification: example inputs paired with the outputs the team expects, run every time the system changes. Dianne Penn, who leads product for Anthropic’s research teams, described the eval-driven development loop on Lenny’s Podcast in July 2026.

The New Stack reported in The 24-hour experiment that helped Anthropic find its identity that her team builds about 30 to 40 representative examples for each major feature. A paragraph can say what good looks like, but an eval checks it on every build.

Review the Prototype’s Defaults

Here the inversion gets costly, and enthusiasm makes it harder to see. The research nonprofit METR explained in We are Changing our Developer Productivity Experiment Design why it was redesigning its 2025 productivity study.

Between 30 and 50 percent of surveyed developers declined to submit some tasks because they did not want to do them without artificial intelligence. The measurement broke on the affection of the people being measured.

The prototype answers the question you asked it. It also quietly answers about forty you did not.

Failure paths, blank screens, the data model, the accessibility of a control grabbed from a library: all decided, none discussed. The pattern I keep running into is the borrowed component nobody logged as a choice, a date picker or a modal in production because it arrived inside a demonstration everyone liked.

Starting from solved patterns is right; starting from them without logging which ones is how they ship unexamined. My Automation Bias entry explains the pull: a produced answer feels more settled than a proposed one. In regulated work, the document is still the artifact of record.

The beginning of agents.md file.

Write for Coding Agents

The build-first and specification-first camps look like rivals, but they mostly describe the same loop from opposite ends. In September 2025, GitHub released Spec Kit, described in Spec-driven development with AI: Get started with a new open source toolkit.

It starts with a specification that becomes the source of truth an agent uses to generate, test, and validate code. That sounds like requirements-first work until you ask who the document is for.

Both camps are right, because they are describing two different documents for two different readers.

An approver wanted confidence. An agent needs constraints: the boundary conditions, the naming rules, the thing you must never do to the billing table. You cannot write those precisely from imagination; you write them from the version you built, watched fail, and corrected.

Those constraints then move into the agent harness, the instruction files, permissions, hooks, and tests around the model, where the instructions state the rules and the rest enforce them. The harness becomes the guardrail.

GitHub’s study of more than 2,500 repositories, How to write a great agents.md: Lessons from over 2,500 repositories, found most agent files fail by being too vague and advises adding detail as the agent makes mistakes. That is writing from the build under another name. The agent’s source of truth sits downstream of the team’s: the prototype writes the specification, and that specification briefs the next build.

Discard the First Prototype

Brooks had a second line. In The Mythical Man-Month, he told managers to “plan to throw one away; you will, anyhow.” Teams that build first have to take that advice literally, and most do not.

The afternoon prototype gets a real URL, then a real user, then a ticket to harden it, and nobody ever decides it became the product if expectations are set well.

Developers already feel what code that almost works costs them.

Stack Overflow surveyed more than 49,000 developers for Developers remain willing but reluctant to use AI: The 2025 Developer Survey results are here, and 45 percent named solutions that are almost right as their top frustration. Two-thirds said they spend more time fixing that kind of code.

A prototype is supposed to be almost right.

Production is not, and the specification is where a team writes down which of the two it is holding.

Conclusion

None of this makes documentation optional. It moves the document to the point in the sequence where it can be accurate, which is after somebody has touched the thing it describes. It also gives research something new to put in front of users every week, which no document offers.

The requirements document was always a forecast dressed as a contract, and forecasts were the best instrument available while building stayed costly. That has stopped being true for a widening slice of work, and the practice around it has not caught up.

What I would watch on your team is the gap between the written schedule and the observed behavior. The calendar still says specification review on Tuesday. The Slack thread says somebody built it Sunday night. When those two facts sit side by side and nobody remarks on it, your process is describing a cost structure that no longer exists.

I would not sell the new order as a method, and I would distrust anyone who does. Building first smuggles in decisions nobody chose, and that cost is real. I would rather audit a working thing than defend a confident paragraph about a problem that turned out not to exist.

Reorder Your Next Feature

  • Build and test the smallest version. One screen built from components your design system already solved, shown to five users before anyone books the review. Fix between sessions, then put a new build in front of new people every week.
  • Write from the build. Let your coding tool draft the specification from the prototype, then add the reasoning it leaves out. When the prototype and the document disagree, fix the document. Replace every sentence beginning “the system shall” with one naming the attempt, the failure, and the option left standing. If you could not defend a line in a live demonstration, it is still a forecast and goes in the open column.
  • Audit the silent defaults. Walk the empty fields, the error messages, and every borrowed component; twenty minutes catches most of what the demonstration hid.
  • Write for the executor. A coding agent follows instructions literally and fills silence with invention, so name constraints and prohibitions, not intentions. Move the ones that matter into the harness, where a hook or a test enforces them, and for model-driven features, let the eval set serve as the specification.


Prototypes have always been the most effective specification-especially with AI was originally published in UX Collective on Medium, where people are continuing the conversation by highlighting and responding to this story.

Article Categories:
Technology

Leave a Comment