Engineer Abandons Manual Coding for Six Months to Test AI Agent Orchestration
A six-month experiment at exe.dev explores the shift from writing syntax to directing autonomous AI agents.
An engineer at exe.dev spent six months testing the limits of autonomous AI, committing to a strict rule of not writing a single line of code by hand. Starting in February of this year, the developer transitioned from a manual implementer to a high-level orchestrator to determine if AI agents could fully replace the typing process in professional software engineering.
According to the exe.dev blog, the author maintained this agent-exclusive workflow for half a year. The experiment focused on the transition from maintaining a granular mental map of the codebase to directing agents that can edit multiple files and execute tests. The author noted that they previously relied on a "superpower" of knowing the entire system's interfaces and the specific reasoning behind architectural decisions—a depth of knowledge that is challenged when the human is removed from the actual implementation.
The Shift to Orchestration
This experiment arrives as AI coding tools evolve from simple autocomplete suggestions, such as GitHub Copilot, into autonomous agents. While early assistants helped with individual lines of code, current agents can manage complex tasks across a project's directory. This shift changes the developer's role from a manual implementer to a system orchestrator, where the primary activity is no longer typing syntax but managing the agent's output and intent.
Implications for Engineering
This transition represents a fundamental shift in the software engineering discipline. If developers stop writing the lines of code themselves, the most critical skills move away from syntax and implementation details toward system design, rigorous verification, and the ability to communicate precise intent to an AI. However, this model raises significant questions regarding the erosion of deep codebase knowledge and the long-term maintainability of systems where no human has manually touched the source code.
The Path Forward
As agent-first workflows become more common, the industry must determine if the productivity gains of orchestration outweigh the loss of intimate system understanding. While the exe.dev experiment demonstrates the viability of removing the human from the typing process, the long-term impact on architectural integrity and the developer's mental model of the system remains a key area for observation.