Writing down concrete examples before asking an AI agent for code, and then letting the agent work through a classic test-driven loop, produces far more correct and far cleaner code than the loose prompting known as vibe coding. That is the central finding of a workflow called EXACT, developed by two consultants at the IT consultancy codecentric and backed by benchmark runs on tasks that the models had never seen. On one such task, Claude Opus 5 reached 27% correctness from a prose description and 94% from mapped examples. On another, the jump was from 15% to 100%.
Why vibe coding goes wrong
The workflow grew out of experiments at technical conferences and on real client projects. The pattern the codecentric team kept seeing was that unstructured vibe coding delivers code quickly, but the code rarely matches what the user actually wanted, and it carries serious quality deficits. The response was not to abandon AI agents but to adapt long-standing engineering techniques, test-driven development (TDD) and refactoring, so that they steer the model instead of being skipped. The name EXACT is a deliberate play on the goal: getting exactly the desired behavior rather than an approximation of it.
A related idea frames the whole approach. Daniel Terhorst-North and Matt Wynne have argued that TDD is better understood as Example-Guided Development, an umbrella that also covers acceptance test-driven development, behavior-driven development and specification by example. The argument fits large language models (LLMs) unusually well: they perform much better when handed concrete examples than when given abstract or theoretical descriptions of requirements.
The five stages of the EXACT workflow

▲ The five stages of the EXACT workflow
EXACT runs as a sequence of five connected stages, moving from human conversation toward executable code.
- Example Mapping. A collaborative modeling technique created by Matt Wynne, in which a team breaks a user story down into rules and concrete examples on sticky notes. This stage is entirely human and is meant to build a shared mental model quickly.
- Specs / Test List. The mapped examples become a natural-language list of tests, echoing Kent Beck's Canon TDD idea of keeping a living checklist of scenarios. Here engineers work directly with the LLM through the EXACT coding harness, and the model's job is to critique the list: find missing edge cases, overlooked permutations and scenarios the examples never covered.
- Test implementation. Items from the list are turned into real tests, one at a time.
- TDD inner cycle. The agent cycles through red (write a failing test), green (make it pass) and refactor (clean up without changing behavior).
- Implementation. The loop continues item by item until a working implementation exists.
The first half of the workflow is about understanding, collaboration and conversation rather than dense documentation. Techniques borrowed from domain-driven design, such as EventStorming and domain storytelling, sit alongside Example Mapping as ways to clarify behavior before an agent is ever prompted. The point is to shift thinking left and avoid the familiar trap of reviewing an enormous pull request only after the code has been written.
Measuring it on tasks the model has never seen
To test the workflow rigorously, the codecentric team set up an empirical lab that runs across different LLMs, harnesses and programming languages. Two design choices make the results credible. First, they wrote new code katas, small practice problems, so the benchmark challenges could not already exist in the models' training data. Second, they kept a private, comprehensive suite of acceptance tests hidden from the AI, and used it to evaluate correctness independently.
The first comparison pits prose-based prompts, the typical vibe-coding input, against Example Mapping, both running on Claude Opus 5 inside the EXACT workflow with six runs per cell.
| Novel task | Prose correctness | Example Mapping correctness | Gain |
|---|---|---|---|
| Claim Office | 27% | 94% | +67 percentage points |
| Sphinx Score | 15% | 100% | +85 percentage points |
Across their test cases, the team reports that Example Mapping consistently lifts correctness by 60, 70 or 80 percentage points and sometimes more. The explanation offered is straightforward: examples establish precise constraints and clear expectations, while prose leaves the model to guess.
Why more Markdown does not fix the problem
The codecentric consultants draw a contrast between teams that build tools for themselves, such as the Claude Code team, where requirements are naturally intuitive, and the enterprise settings where consultants usually work. In banking, insurance or e-commerce, developers are rarely native domain experts, and feature requests communicated purely in prose are inherently ambiguous.
That is also their critique of spec-driven development frameworks such as BMAD on GitHub, which have gained popularity by generating multi-phase Markdown architectural specifications. In their view, adding pages of Markdown prose does not remove the underlying ambiguity. Without concrete examples, spec-driven development inherits the same weakness as any other prose requirement.
Plain TDD versus structured TDD
The second benchmark looks inside the inner loop. On the Claim Office task in TypeScript, Claude Code running Claude Opus 5.5 was tested three ways over five runs each, with every variant reaching at least 96% correctness. Plain TDD means a naive prompt that simply tells the model to do TDD with minimal guidance.
| Metric | Plain TDD | EXACT Coding | EXACT + refactor agent |
|---|---|---|---|
| Cognitive complexity (max) | 7.6 | 2.4 | 2.0 |
| Longest function (lines) | 26.2 | 13.0 | 14.2 |
| Mutation score | 0.76 | 0.94 | 0.95 |
| Cost per run | $1.31 | $9.79 | $28.34 |
Cognitive complexity scores how hard a piece of code is to follow, and mutation score measures how good a test suite is at catching deliberately injected bugs, so for that row higher is better; for every other row, lower is better. The structured workflow cuts peak cognitive complexity by roughly two thirds, halves the longest function and pushes the mutation score close to the ceiling. The trade-off is cost: EXACT Coding is about seven times the price of plain TDD per run, and adding a dedicated refactor agent roughly triples it again.
The refactor agent's value depends on the model generation. On the earlier Claude Opus 4.6, a separate refactoring subagent delivered a very large quality boost. On Claude Opus 5.5 the gap has narrowed, which makes the extra spend harder to justify for that model.
Subagents with clean context

▲ Isolated subagent contexts for each TDD phase
The lab began with a single TDD prompt, before skills and tools existed in Claude Code. As context windows grew, performance dropped, and the team connected that to the Stanford paper "Lost in the Middle: How Language Models Use Long Contexts." Its finding is that LLMs retrieve information best from the very beginning and very end of a long context and often miss or ignore what sits in the middle.
The proposed remedy was to split the distinct phases of TDD into specialized subagents, each with a fresh, isolated context window, so that instructions stay sharp and are not diluted by everything that came before. A research harness to test that idea was built over a single weekend, and the benchmark above is the result of running it.
Predictive TDD: make the agent commit before it runs
A core mechanic of the workflow is predictive TDD, an idea popularized by a tabletop TDD game and practiced on the Cyber-Dojo platform. The rule is that before any TDD step executes, the practitioner, human or LLM, must predict the exact outcome. In the red step, the agent must state that the test will fail, name the precise reason and predict the expected error message before issuing the test run command.
Two benefits are claimed. The practice forces the model to stay in touch with the real runtime rather than drifting into plausible-sounding code. And it pushes the immediate domain problem to the front of the model's active context, which, given the Lost in the Middle effect, puts the most important information where the model attends to it best.
How much supervision an agent needs
There is no universal answer, because model capability keeps shifting, so the harness makes autonomy configurable. Developers can inspect every red, green and refactor phase, check in periodically (for example after every three tests or after each refactoring pass), or let the agent run fully autonomously.
The personal preference expressed by the workflow's authors is to stay actively in the loop and make course corrections, which in their experience produces far better results than hands-off execution. The deeper reason is that a human must first build an accurate mental model of the domain and the problem before delegating; an agent cannot compensate for a flawed specification, so human guidance appears essential on any non-trivial task.
One of the consultants joked that his colleague had spent 20 years trying to teach TDD to humans, and an LLM is finally the student that listens and executes the discipline systematically. Developers do not need deep prior TDD mastery to start using the harness; working with it is itself a way to learn the principles. Experienced practitioners can go further by injecting domain heuristics and tailored testing constraints directly into the prompts.
What to take away and what to try
The evidence from the codecentric lab points in one direction: proven craftsmanship practices are not obsolete in the age of coding agents, they are the counterbalance that keeps agent output correct and maintainable. Concrete examples are the dominant lever for correctness, a structured TDD loop is the lever for code and test quality, and the price is paid in tokens.
For teams that want to apply this:
- Run an Example Mapping session with stakeholders before prompting an agent for production code, especially in domains where the developers are not experts.
- Turn the examples into a natural-language test list, then ask the LLM to critique it for missing permutations and edge cases.
- Work through the list sequentially in a red-green-refactor loop rather than handing over a multi-paragraph prose prompt.
- Instruct the agent to predict whether each test will pass or fail, why, and what the error message will be, before running it.
- Isolate refactoring in a separate agent or fresh session; weigh the extra cost against the gain for the model you use.
- Tune supervision to the task: watch each red-green transition closely in unfamiliar architectural territory, and loosen oversight only once you trust the pattern.
- When evaluating any coding agent, build novel katas with hidden test suites so that memorized training data cannot inflate the results.
The full harness and testing lab are open source on GitHub under the repository name agentic_coding_lab, and the authors are writing a book on the method, first in German with an English edition underway.


