Why I stopped trusting fully autonomous coding

I am currently building a modular application for route analysis. Code, architecture and prompting are connected to the same codebase. I use ChatGPT, Codex and Claude in the process.

I write less and less code by hand. But that does not mean engineering knowledge matters less. It is the opposite. The human becomes the architect and has to understand both the technical side and the field where the product will be used. Otherwise, an agent will quickly build something that formally works but solves the wrong problem.

Codex has a mode where the system plans the work, launches agents and continues until it decides the task is finished. On paper, this looks like the next level of autonomy. In practice, my sequential workflow still gives me a more reliable result.

The reason is simple. When I split the work into stages, I can inspect the result, run tests, review the diff and make a commit between versions. During a fully autonomous run, one secondary branch can take over all attention. It becomes the main goal. Then the next secondary task becomes the main goal too. The agent launches more environments and sub-agents, returns to old reports and gradually loses the central thread.

The most unpleasant part comes after a confident final message. Several times I found unnecessary branches, stale files and errors, even though the agent said everything was finished and the repository was in good shape.

I learned that a progress report is not evidence. Green tests do not always mean the project is healthy either. They may confirm that the current function works, while missing that the architecture became more complex, the repository still contains garbage and the original goal has already been replaced.

So I changed the workflow itself.

1. One stage should produce one verifiable result.
2. A separate agent gets a limited task, not the right to redefine the entire route.
3. After each stage, I review the diff, run tests and make a clear commit.
4. Before continuing, I check branches, stale files, unnecessary environments and alignment with the original goal.
5. After two failed directions, the work stops. First, we restate the original assumption. Only then do we choose the next path.

This is not a fight against AI or an attempt to return all programming to humans. I use agents every day and I see how much they amplify one specialist. But more autonomy does not always mean a better result. Sometimes it only means more speed inside the wrong branch.

In my project, the cost of this failure is still clear: extra branches, stale files, errors and wasted time. The story of a large agent swarm shows the same mechanism at a different scale. If a system gets practically unlimited time and budget, millions of branch combinations can lead to results that are impossible to predict in advance. At that point, excessive persistence becomes not only expensive, but dangerous.

Today, the human role is clearer to me than before. An agent can execute an enormous amount of work. The human has to preserve the architecture, the real-world goal and the right to stop the system before a secondary branch becomes a new project.