EXACT Coding: AI-powered development that prioritizes quality over chaotic experimentation

TL;DR

Uncontrolled agentic coding (“vibe coding”) delivers code quickly—and often leads to security and maintenance issues as soon as the software goes live. EXACT Coding (Example-guided AI-Collaborative Test-driven Coding) combines best practices: first examples and clarity, then tests as guidance, then implementation—with humans involved at defined points in the loop. This way, AI remains a collaborative partner, not a black-box generator.

For a deeper dive into the rationale, pitfalls, tooling (rule files, skills, subagents), and a walkthrough of a TDD session, see the 👉book “EXACT Coding” on Leanpub. Teams that want to practice the workflow together can request the full-day EXACT workshop directly from us. See below for more information.

Vibe Coding vs. Engineering Discipline

AI-assisted software development has long been the norm: agents write code, refactor, and iterate. The much-cited term “Vibe Coding” (Andrej Karpathy) describes the extreme variant: letting yourself be driven by AI and barely reading your own code anymore—this might be enough for a weekend experiment, but it quickly becomes risky for productive software. As soon as payment logic, data management, or security boundaries come into play, traceability, testing, and clear requirements matter—not just speed.

Why this classification matters

In many organizations, business units, management, and development teams talk about “AI in programming”—but they mean completely different levels of support. Without a shared understanding, false expectations arise: sometimes AI is touted as a miracle cure, other times it’s demonized as a risk.

The codecentric blog features, among other things, a five-level model of AI-assisted software development (article is written in German): ranging from simple chat to IDE assistance and agents, all the way to spec-driven work with heavy agent usage.

EXACT Coding is not a replacement for this model, but rather a concrete workflow for situations where you use agents effectively—typically at Levels 3 and 4: You remain within the agentic context, but consciously decide what specifications, tests, and human oversight look like.

Sweet Spot: Autonomy and Quality

A helpful illustration is the Autonomy Slider (also popularized by Karpathy): strictly hand-written code on the far left, maximum AI autonomy with often fragile quality on the far right. The curve is not a straight line: With targeted practices, quality can still be ensured even with high AI usage—the question is less “less AI” and more about what guardrails you set.

The slider spans the spectrum between classic, disciplined development and maximally “vibe-driven” AI usage – EXACT Coding targets a deliberately chosen area in between (Fig. 1).

Those who rely solely on vibes run the risk of reinforcing typical patterns of error: hardcoded secrets, security logic in the wrong place, hallucinated dependencies, missing input validation, overengineering, and inconsistent solutions within the same codebase. Added to this is verification debt: the generated code looks convincing, reviews become superficial—until things go wrong in production. For more background and context, see, among other sources, the article "Vibe Coding – What Now?". The article "Bugs, Refactoring, Tests: Where chatbots shine in coding and where they fail" also addresses the role of testing and refactoring in everyday AI work (articles are written in German).

What is EXACT Coding?

EXACT Coding stands for Example-guided AI-Collaborative Test-driven Coding. It is not a new framework, but rather a workflow based on proven ideas from software craftsmanship and collaborative modeling (Behavior-Driven Development, Domain-Driven Design). One concrete manifestation of this is Example Mapping: In a short workshop, participants jointly clarify the story, rules, examples, and open questions—visibly and in a structured way—before the first line of code or the first prompt is written. The workflow is designed to work well with modern large language models and agents. The AI is integrated collaboratively, not as a substitute for thinking and responsibility.

To put theory into practice, the book includes a fully documented TDD session. The card game Overlords: The Card Game serves as an example. Since this game rarely appears in the training data of LLMs, you can observe live how the AI solves real logic problems rather than just reciting from memory. The core of EXACT coding is a three-part principle you can keep in mind:

• Examples Before Code – Ambiguity in natural language is reduced through concrete examples before the first line of code is written; Example Mapping typically provides the common framework for this (story, rules, examples, open questions).
• Tests as Guidance – A failed test (Red) defines a small, clear next step and keeps the context manageable for the model.
• Humans as a corrective – At defined points (e.g., after Red, Green, Refactor), humans remain the authority for design, safety, and context – Human in the Loop, not as a brake, but as quality assurance.

The Process in Seven Steps (Summary)

From Example Mapping and natural language specifications, the process moves into the TDD cycle (Test, Implementation, Refactoring)—with clear roles for humans and AI.

The workflow combines collaborative requirements clarification with the Red–Green–Refactor cycle; the diagram provides a concise summary of the process (Fig. 2).

1. Define scope – Choose a feature small enough so that the LLM context does not explode (story slicing, vertical slices).
2. Example mapping – Short workshop with story, rules, examples, and open questions (e.g., colored cards or digital board).
3. Test list – Create an organized list of test cases from the examples; generated by humans or AI, verified by humans.
4. Red – A test from the list is run and fails; the scope remains minimal.
5. Green – Minimal implementation until the test passes – agents often excel here.
6. Refactor – Improve structure and readability without changing semantics; human experience is essential here.
7. Repeat – Until the list is worked through; new insights are incorporated into the list as new entries.

This keeps the work in small, verifiable steps – which is exactly what addresses typical LLM weaknesses such as context loss in long prompts (“Lost in the Middle”) and vague requirements.

Autonomy Levels: Setting the Slider Consciously

In practice, you can adjust the degree of AI autonomy. To avoid overlap with the steps of the EXACT workflow, the typical settings are labeled here as Options A–C:

• Level 1: The agent works through the test list largely on its own; review at the end. Fast, but risky if something goes fundamentally wrong early on.
• Level 2: Pause after every complete Red–Green–Refactor cycle – good balance of speed and control.
• Level 3: Pause after every phase (Red, Green, Refactor) – maximum control, slower.

Recommendation: If anything is unclear or test behavior seems strange, stop immediately and clarify—early intervention is better than a major cleanup later.

Rule files, commands, skills, and subagents (e.g., in Cursor or Claude Code) help maintain TDD discipline and stopping points without having to reinvent every prompt—the details and examples are covered in the book.

Deep Dive: Book on Leanpub

The blog post provides the roadmap. If you want to understand the depth of reasoning, typical agent error patterns, a walkthrough of a TDD session (including an example domain), and practical configuration (rules, skills, agents), you’ll find it in the book “EXACT Coding” on Leanpub (in German). There, the workflow is described in a way that allows you to adapt it to real projects—including a reference to the accompanying exercise repository EXACT-Coding-Exercises with sample rules and structures.

Workshop: Trying out EXACT Coding Together

Theory and the blog aren’t always enough—some teams want to walk through the process together. For this, we offer a full-day workshop closely aligned with the book’s themes: principles from the book, concrete exercises, and examples from everyday project work. Participants work in pairs and small mobs (drivers plus navigators) and go through the EXACT workflow step by step—from example mapping to TDD to refactoring with AI support. Contact: Reach out to us via the usual codecentric channels or directly (e.g., via our LinkedIn profiles: Marco und Ferdi – see the book and imprint on Leanpub). The editorial team can provide a specific booking URL upon request.

Conclusion

EXACT Coding aims for the sweet spot: noticeably higher productivity through AI, without sacrificing quality or control. It does not replace responsible architecture or security reviews—and it does not claim that “Level 5” (fully autonomous product development without human review) has been achieved. However, it provides a transparent, repeatable approach for teams to use agents productively without ending up in a state of chaos.