Production schedule disruptions and shop-floor equipment downtime begin precisely when management takes green test reports from autonomous models at face value. Practice demonstrates that a subagent is entirely capable of delivering a wave of tasks with a detailed single-page report claiming absolute release readiness, only for the actual build deployment to instantly crash at the compilation stage due to the routine absence of half the declared classes in the target file. Engineering leadership faces a harsh reality: a subagent accepting a task does not mean the code physically functions.

Autonomous development driven by AI agents inevitably runs into the systemic problem of verifying external reports, requiring the construction of specialized validation loops and the assignment of controllers without write permissions. To avoid paying for the illusion of autonomy through a multi-fold increase in manual debugging costs, projects must be wrapped in a rigid role-based architecture. In a case study involving the creation of a control system for small-scale electric motor production—comprising a Python server, shop-floor Android tablets, and seven internal AI agents—the author built the functionality not manually, but via a team of Claude Code subagents.

What does manual verification of code written by autonomous agents actually cost?

It costs hours of aborted builds whenever the architecture relies on neural network memory rather than fixed engineering constraints. In the Claude Code repository, each subagent is represented by a markdown file located in the .claude/agents/ directory. The project utilizes a total of fifteen such subagent files, where the frontmatter strictly defines the permitted tooling and reasoning model, while the body serves as the system prompt. Seven of the team's agents operate on the flagship Opus model for complex decisions, while the other seven run on Sonnet for direct task execution.

Subordination Architecture and Single Source of Truth

_The primary hazard of blind faith in neural network speed lies in their tendency to improvise requirements on the fly, inflating development budgets._ The first agent whose system prompt required a complete rewrite was the tech lead: if a model relies on its own memory of context, the system degrades instantly. The solution was to anchor five client-approved specification documents in the prompt as the single source of truth, which the team no longer revisits, focusing solely on execution.

«The Docs/ working directory contains five documents. They are approved by the client, and the team does not revisit their discussion—they simply execute them».

Any deviation from regulations triggers a codebase rollback: the tech lead prompt enforces eleven architectural principles. Tasks are broken down into one- to three-day cycles with an obligatory execution chain running from the database through the backend and tests directly to the client tier. Furthermore, a specialized AI critical actions rule categorically prohibits agents from issuing revisions, consuming materials, or releasing work orders—these financially sensitive operations remain strictly human-exclusive.

Whitelist of Tools and Evidence-Based Acceptance

It might seem that AI agents can write code multiple times faster than programmers, and that erecting rigid control barriers merely creates an artificial bottleneck in the delivery pipeline. AI agents can autonomously write code faster than humans, and strict limitations only slow down development velocity—yet in practice, unrestricted file modification access introduces hidden defects that multiply the resources required for subsequent audits.

To eliminate conflicts of interest, the primary Claude Code agent in the main session is granted a strict monopoly on commits and integration, whereas standard subagents never write to git. In the git log history, the author is always listed exclusively as APP Motors Team, making it impossible to distinguish human work from model output. Releases themselves are distributed across parallel waves of two to four subagents operating in isolated git worktree branches with a strict freeze on shared files.

However, the critical control gate is enforced by a specialized agent named app-motors-release-controller. Its permissions are intentionally curtailed: the controller possesses a strict whitelist of tools consisting of Read, Glob, Grep, and Bash, but lacks Write and Edit commands entirely. It is physically incapable of editing the code under review or fixing discovered bugs, accepting results strictly on material evidence.

«build-verifier runs actual builds and tests and reports honestly. You do not fix code—not even an obvious typo».

_The final arbiter is the build-verifier agent, tasked with generating an objective assessment without attempting to patch failing code with its own corrections._ No model assurances regarding test success carry any validity without an actual execution run.

What came before

While back in late August an unchecked agent kept inflating pull requests past four thousand lines by rebasing straight into main, slicing fifteen Claude Code subagents into thinkers and doers finally reined in the chaos. Restricting even the reasoning power of Opus from releasing production work orders turns agentic speed into actual software rather than expensive manual rollback work. How many hours of manual auditing will the hard ban on production releases truly save if fifteen subagents still draft factory code across five master specifications?

Our stories: Claude Code by Anthropic Lets One Dev Control Five AI Agents (March 23); Codex vs Claude: Why Coding Agents Fail Production Tests (August 23).

AI AgentsAutonomous AgentsDeveloper ProductivityCoding AI AgentsAnthropic