The act of coding is no longer about syntax; it is about manifestation. As Andre Karpathy recently articulated, the modern developer’s workflow has shifted from the manual labor of typing lines to the high-level orchestration of “claw-like” agents. We have entered a state of perpetual AI psychosis—a frantic, exhilarating race to maximize token throughput and delegate the entirety of the software development lifecycle to autonomous entities.
The Death of the Manual Workflow
For decades, the bottleneck of software engineering was the human interface: the keyboard, the IDE, and the cognitive load of managing state. That era effectively ended in December. The current paradigm is defined by a 20/80 split—or even more extreme—where the engineer acts as a conductor rather than a composer.
The developer is no longer writing functions; they are managing “macro actions.” You define an objective, delegate it to an agent, and review the output. If the system fails, it is rarely a lack of capability in the model; it is a “skill issue” in the prompt, the memory tool, or the orchestration logic. The engineer’s new primary skill is the ability to structure these agentic loops so they can run autonomously, removing the human from the loop entirely.
The Psychosis of Infinite Productivity
This shift creates a unique, high-pressure environment. If you aren’t maximizing your token throughput, you feel the same anxiety a PhD student feels when their GPU cluster sits idle. The goal is to reach a state where you are not the bottleneck.
This is why the “agentic web” is so compelling. It isn’t just about coding; it’s about refactoring the entire digital experience. Karpathy’s “Dobby the Elf” home automation setup—where a single agent manages Sonos, HVAC, security, and lighting through natural language—demonstrates that the current app-based ecosystem is an artifact of a pre-agentic world. We don’t need bespoke UIs for every device; we need exposed API endpoints and an agent to act as the glue.
The Jagged Frontier of Intelligence
Despite the hype, the current state of agentic workflows is “jagged.” These models are brilliant at verifiable tasks—like writing CUDA kernels or optimizing hyperparameter loops—but they stumble on the “soft” edges of human intent. They can move mountains of code but still struggle to tell a joke that wasn’t part of their training data five years ago.
This jaggedness suggests that we are not yet seeing a monolithic “superintelligence.” Instead, we are seeing specialized capabilities that are heavily dependent on reinforcement learning. The frontier labs are optimizing for verifiable rewards, leaving the rest of the model’s intelligence to meander.
The Future: From Coding to Curating
What does mastery look like in a world where the agent does the heavy lifting? It looks like the curation of “Program MD” files—markdown documents that define the roles, objectives, and collaboration protocols of an entire research organization.
The future of engineering is not writing code; it is writing the instructions for the system that writes the code. We are moving toward a model where “education” is no longer a human-to-human transfer of knowledge, but the creation of curricula for agents. If you can explain a concept to an agent, the agent can explain it to the human with infinite patience and perfect personalization.
The ultimate implication is a radical decentralization of research. If we can build systems where untrusted workers on the internet can contribute to verified research loops—much like Folding@home—we might see the collective intelligence of the swarm outpace the centralized, opaque frontier labs.
We are currently in a state of transition where the human is still the architect, but the architecture is becoming increasingly ephemeral. The software of tomorrow won’t be built; it will be manifested. The question for the next generation of engineers is not how well they can code, but how effectively they can command the agents that are, quite literally, rewriting the world.