Coding agents without drift

Why this conversation

People now work with coding agents to generate whole applications. That creates a problem for anyone who has to run, review or answer for that code: the agents generate a lot of it, it is hard to review and understand, and the design documents written at the start stop describing the system after a few iterations. At AGNTCon + MCPCon Europe in Amsterdam the host sat down with Benjamin Hindman, founder and CEO of Reboot, whose answer is a framework that lets you understand an application at the level of its domain rather than its lines of code.

The story of the week it was filmed is in AGNTCon + MCPCon Europe 2026: who we met.

The spec, extracted from the code

Reboot is a new application framework for building full-stack apps. You ask your coding agent, Codex or Claude for example, to use it to build the app or its backend. The framework has primitives and constructs that make it possible to extract, from the code the agent wrote, the domain objects of the application and how they call one another.

Benjamin contrasts this with what many teams do today. They ask the agent for a Markdown file that captures the domain objects and data abstractions, write down a set of behaviours, and hope the agent gets from that file to a working implementation. It may do so the first time. As the application evolves, the code drifts away from the original file and the visibility is gone.

That is also the difference from spec-driven development. There, the spec is written first and you hope the implementation matches. In Reboot, “the spec is literally extracted from the code”, so it is always up to date. The trade-off is that it only works for applications built in the framework, not for arbitrary code.

The host described the problem from his own experience: as a code base grew under spec-driven development it became hard to maintain, and a new spec could override an earlier one. In Reboot, Benjamin explains, you ask the agent for a new feature, look at the domain objects that came out of it, and if you do not like the design you go back and try again with a clearer idea of what should change. He compares it to engineers drawing objects on a whiteboard and connecting them with lines, and then talking to the coding agent at that level.

Behaviours as tests

Reboot goes beyond domain objects to the behaviours of the application. These are written in the syntax of behaviour-driven development tools such as Cucumber and Gherkin, and run as tests. The usual difficulty with BDD, which the host had run into, is matching natural language to the implementation behind it. Because Reboot exposes the domain objects, the English sentences use those objects directly, and each Cucumber sentence is matched to an actual call on a domain object in the backend.

The developer dashboard shows both: the domain objects and the BDD features. There is also an integration with Playwright, so some features run through the full-stack app and the dashboard shows screenshots as the scenario clicks through the web app. The next step the team wants is an audit view of the events as they occur, so that people can feel confident about shipping what the agent built.

Benjamin’s view of the engineer’s job follows from this: “we should no longer be in the business of writing the plumbing”, but engineers should still care about the architecture: the domain models, the features and how behaviours should work.

What newcomers should learn

The team tried an experiment: let a coding agent keep building a sophisticated app, feature after feature, with no human involvement. Even in Reboot the result was complicated, and the team found themselves asking why the agent had designed the domain objects the way it did.

So his advice for people entering the industry is to learn the higher-level ideas: data structures, how systems call other systems, service boundaries, modular architecture and packages, and when a problem calls for a queue or a sorted map. That is how a business gets mapped into software at the domain level, and it is where he expects humans to keep working. The finest details of a language’s syntax, he thinks, will serve them far less.

Where to try it

Start at reboot.dev or docs.reboot.dev, where the left-hand side offers paths to start building with Claude or with Codex. Bring your own harness, use Git and normal engineering practice, ask the agent to build an app, and ask it to show you the Reboot developer dashboard to see the domain objects appear.