The promise of AI coding agents — autonomous software that writes, tests, and ships code with minimal human oversight — has captivated Silicon Valley and Wall Street alike. Billions of dollars have poured into startups and infrastructure built around the premise that these agents will revolutionize software development. But a detailed technical retrospective from one of the industry’s most credible practitioners reveals a far more nuanced picture: AI agents are genuinely useful, sometimes transformative, but riddled with failure modes that make full autonomy a distant prospect rather than an imminent reality.
David Crawshaw, a veteran software engineer and co-founder of Tailscale, published an extensive account of his experience using AI coding agents over the past eight months on his personal blog. The piece, which has circulated widely among developers and technology executives, serves as both a practitioner’s guide and a sober counterweight to the breathless hype surrounding agentic AI. Crawshaw’s findings suggest that while agents have become indispensable parts of his workflow, the gap between “useful tool” and “autonomous developer” remains enormous — and closing it will require fundamental advances, not just incremental model improvements.
From Skeptic to Daily User: The Evolution of Agent-Assisted Development
Crawshaw’s account picks up where an earlier essay left off, building on roughly a year and a half of continuous experimentation with AI coding agents. His trajectory mirrors that of many senior engineers: initial skepticism gave way to cautious adoption, which eventually became deep integration into daily work. He now estimates that agents are involved in the majority of his coding tasks, handling everything from boilerplate generation to complex refactoring across multiple files. The productivity gains, he reports, are real and substantial — but they come with significant caveats that rarely make it into marketing materials or investor presentations.
The most striking aspect of Crawshaw’s account is his detailed taxonomy of agent failure modes. Rather than offering a simple thumbs-up or thumbs-down verdict, he catalogs the specific ways agents go wrong and the strategies he has developed to mitigate those failures. This level of granularity is rare in public discourse about AI tools, where discussions tend to oscillate between utopian proclamations and dismissive skepticism. His experience suggests that the real story of AI agents is one of careful human-machine collaboration, not autonomous replacement.
The Persistent Problem of Context and Drift
One of the central challenges Crawshaw identifies is what might be called “context drift” — the tendency of agents to lose track of the broader goals of a task as they work through individual steps. An agent might successfully complete each sub-task in isolation while producing an end result that fails to cohere. This problem is particularly acute in larger codebases, where understanding the relationships between components is as important as understanding any single component. As Crawshaw describes on his blog, agents frequently make changes that are locally correct but globally destructive, introducing subtle bugs that only manifest when the full system is exercised.
This failure mode has profound implications for the economics of AI-assisted development. If an agent can generate code ten times faster than a human but requires extensive human review to catch coherence failures, the net productivity gain may be far smaller than the raw speed improvement suggests. Crawshaw’s experience indicates that the review burden scales with the complexity and size of the task — precisely the kinds of tasks where autonomous agents would deliver the most value. The result is a paradox: agents are most reliable on simple tasks where the time savings are modest, and least reliable on complex tasks where the potential savings are enormous.
Why Bigger Models Haven’t Solved the Fundamental Challenges
A recurring theme in Crawshaw’s analysis is that improvements in underlying language models — the foundation on which agents are built — have not eliminated the core difficulties of agentic coding. Each new generation of models from OpenAI, Anthropic, and Google has brought genuine improvements in code quality and reasoning ability. Yet the fundamental failure modes persist. Agents still hallucinate API calls that don’t exist, still lose track of project conventions, and still make confidently wrong architectural decisions. The improvements are quantitative rather than qualitative: agents fail less often, but they fail in the same ways.
This observation carries significant weight given Crawshaw’s technical background. As a co-founder of Tailscale, a widely used networking tool, and a former member of the Go programming language team at Google, he brings a level of engineering rigor to his assessments that distinguishes his account from casual user reviews. His finding that model improvements have not fundamentally changed the agent experience challenges a core assumption of many AI investment theses — namely, that scaling laws will inevitably close the gap between current agent capabilities and full autonomy.
The Human in the Loop: Essential, Not Optional
Crawshaw’s most important practical insight may be his emphasis on the irreducibility of human oversight. Effective use of AI agents, he argues, requires not less engineering skill but more. The developer must understand the codebase well enough to specify tasks precisely, review agent output critically, and intervene when the agent’s approach diverges from the correct path. In his telling, the best mental model for an AI agent is not a junior developer who can be left alone, but a highly capable but unreliable collaborator who requires constant supervision.
This framing has implications that extend well beyond individual developer productivity. Companies that have reorganized their engineering teams around the assumption that agents can replace junior developers may find themselves with a supervision deficit. Senior engineers, already in short supply, become even more critical in an agent-augmented workflow because they are the ones capable of catching the subtle errors that agents introduce. The bottleneck in software development, in other words, may shift from writing code to reviewing it — a task that is harder to automate and harder to scale.
Tooling, Prompting, and the Art of Agent Management
A significant portion of Crawshaw’s essay is devoted to the practical mechanics of working with agents effectively. He discusses strategies for structuring prompts, breaking tasks into agent-appropriate chunks, and building tooling that constrains agent behavior in productive ways. These techniques, developed through months of trial and error, represent a kind of emerging craft knowledge that is not yet widely documented or taught. As he details on crawshaw.io, the difference between a productive agent session and a frustrating one often comes down to how the task is framed rather than the capability of the underlying model.
This finding underscores a broader point about the current state of AI tooling: the technology is powerful but raw, and extracting value from it requires significant skill and patience. The analogy to early computing is apt. The first generation of programmers had to understand machine architecture intimately to write effective code. Similarly, today’s most effective agent users are those who understand the strengths and limitations of language models well enough to work with them rather than against them. This skill set — part prompt engineering, part software architecture, part quality assurance — is still being defined.
What This Means for the Industry’s Billion-Dollar Bets
The investment community has placed enormous bets on the premise that AI agents will rapidly transform software development. Venture capital firms have funded dozens of startups building agent-based coding tools, and major technology companies have integrated agent capabilities into their core products. Crawshaw’s account does not invalidate these investments, but it suggests that the timeline to full autonomy is longer and the path more complicated than many investors assume. The technology is genuinely useful today, but its current form is better described as a powerful augmentation tool than a replacement for human developers.
The implications extend to workforce planning across the technology sector. If agents remain fundamentally dependent on skilled human oversight, the demand for experienced software engineers may not decline as quickly as some projections suggest. Instead, the nature of the work may shift — from writing code to directing and reviewing agent-generated code — without reducing the need for deep technical expertise. Companies that invest in training their engineers to work effectively with agents may gain a significant competitive advantage over those that simply deploy the tools and hope for autonomous results.
The Road Ahead: Incremental Progress, Not Revolution
Crawshaw’s eight-month retrospective paints a picture of a technology that is advancing steadily but not exponentially. Each month brings small improvements in reliability, capability, and usability. But the fundamental challenges — context management, coherence over long tasks, architectural judgment — remain unsolved. These are not problems that can be brute-forced with larger models or more compute. They require advances in how agents plan, reason about constraints, and maintain state over extended interactions.
For industry insiders, the takeaway is clear: AI coding agents are here to stay, and they deliver real value when used skillfully. But the vision of fully autonomous software development remains aspirational. The engineers, executives, and investors who will benefit most from this technology are those who approach it with the kind of clear-eyed pragmatism that Crawshaw demonstrates — embracing the gains, acknowledging the limitations, and doing the hard work of building effective human-agent workflows. The revolution in software development is underway, but it is an evolution measured in careful, compounding improvements rather than a single dramatic leap.
WebProNews is an iEntry Publication