Developers are moving from writing code to supervising agents
Santiago Valdarrama says he has spent two weeks judging agent output without reading it, a workflow software vendors are racing to formalize.
By Ryan Merket · Published
Why it matters
Coding agents are shifting engineering work from line-by-line implementation toward task definition, verification and supervision, forcing IDE vendors to redesign their core interface.
Santiago L. Valdarrama (@svpino), a machine-learning engineer and educator, said he has stopped reading AI-generated code and expects software development tools to shift away from the traditional integrated development environment.
"I'm officially done reading AI-generated code," Valdarrama wrote in a three-post thread on X on August 8th. He said two weeks had passed since he last inspected the code produced by his agents, then declared the IDE "on its way to the graveyard." The post had drawn more than 252,000 views, 3,500 likes and 500 replies at the time captured by X.
The claim is anecdotal. Valdarrama did not specify which agents he used, the projects he assigned them or the checks that replaced reading their output. His workflow still captures a real change in software development: engineers are spending less time composing individual lines and more time defining tasks, evaluating results and deciding what reaches production.
Valdarrama brings three decades of programming experience to that argument. On his website, he says he wrote his first line of code in Turbo Pascal in 1994. He now runs a production-focused AI and machine-learning course that covers evaluation, deployment, monitoring, agentic systems and human-in-the-loop workflows. Valdarrama says more than 2,000 students have completed the program since he started it in March 2023.
The interface fight has already started
Valdarrama's prediction lands as the largest AI and developer-tool companies redesign the interface around software work.
On February 2nd, 2026, OpenAI introduced the Codex app as a command center for running multiple coding agents in parallel. OpenAI explicitly argued that existing IDEs and terminal tools were not designed for developers supervising agents across tasks that can run for hours, days or weeks. The app organizes work around delegation, background execution and agent management rather than a file open in an editor.
Microsoft's Visual Studio Code is taking the opposite product route: absorbing the agent control layer into the IDE. Its current agent interface lets developers manage local, background, cloud and third-party agents, then move between an agent-first view and the conventional code editor. Developers can still inspect files, debug and edit manually when a task requires it.
That makes the IDE's disappearance less certain than its demotion. The editor is becoming one surface inside a larger orchestration product. The contest is over which screen engineers open first: a source file or a queue of delegated jobs.
Valdarrama had been developing this thesis before Saturday's thread. In a February 25th essay, he argued that human-readable programming languages function as an intermediate layer for human oversight and could eventually give way to representations optimized for machines. In an April 3rd, 2025 essay, he separated code production from the harder work of selecting problems, framing them and designing maintainable systems.
His latest post pushes that view into daily practice. In a reply, Valdarrama compared manually writing code with writing assembly, a skill that higher-level languages made unnecessary for most developers. The comparison assumes agents can supply an equally dependable abstraction layer. Current evidence remains mixed.
Review moves up the stack
Anthropic's June analysis of roughly 400,000 Claude Code sessions found that users made about 70% of planning decisions while Claude made about 80% of execution decisions. Domain expertise remained a strong predictor of success: experienced users gave more precise directions, asked for better verification and recovered more effectively when the agent failed.
That division resembles the workflow Valdarrama described. Humans define the desired behavior and constraints; agents choose files, write the implementation and run commands. The human review surface moves toward plans, tests, logs, runtime behavior and pull-request summaries.
Source-level inspection still protects against failures that passing tests may miss. A 2025 study of more than 500,000 Python and Java samples, accepted at the IEEE International Symposium on Software Reliability Engineering, found distinct defect patterns in AI-generated code and a higher incidence of high-risk security vulnerabilities. The samples came from controlled comparisons rather than Valdarrama's workflow, but the findings show why agent autonomy does not eliminate quality assurance.
Anthropic has also warned that autonomous agents can misread intent, take unintended actions and encounter prompt-injection attacks. Its agent safety guidance emphasizes reviewing plans and retaining intervention points even when users no longer approve every individual action.
Valdarrama's thread captures where the developer interface is heading: engineers supervising outcomes while agents handle implementation. IDE vendors can survive that shift by turning editors into control rooms. A tool designed mainly around typing and reading source code will have a smaller role when the first artifact a developer reviews is an agent's plan, test report or finished change.