Anthropic's flagship coding agent is simultaneously the most impressive and most frustrating AI development tool on the market. The gap between those two realities is shaping the next phase of the AI tools race.
In early 2026, two things happened that perfectly capture the strange state of AI-assisted software development. A research scientist at Anthropic used Claude Code to discover remotely exploitable security vulnerabilities in the Linux kernel, including one that had gone undetected for 23 years. Around the same time, developers flooded a GitHub issue thread with complaints that Claude Code had become essentially unusable for the kind of routine complex engineering tasks they relied on it for daily. Both things are true at once, and the tension between them explains a lot about where AI coding tools are headed.
The Bug Hunter and the Broken Workflow
Nicholas Carlini, a research scientist at Anthropic, reported at the [un]prompted AI security conference that he had used Claude Code to find multiple remotely exploitable heap buffer overflows in the Linux kernel. One of those bugs had been hiding in the network file share (NFS) driver for over two decades.
"I have never found one of these in my life before. This is very, very, very hard to do," Carlini told mtlynch.io.
What made the discovery remarkable wasn't just the result but the method. Carlini's approach was almost comically simple: a shell script that iterated over every file in the Linux kernel source tree, pointed Claude Code at each one, and asked it to find vulnerabilities. The script framed the task as a capture-the-flag competition, a light prompt engineering trick.
The AI needed minimal oversight to identify a bug that required deep understanding of the NFS protocol's internal mechanics, including how specific data structures interact across network boundaries.
This is genuinely impressive. It suggests Claude Code can synthesize information across large codebases in ways that even experienced security researchers struggle to match. But the story doesn't end there.
On GitHub, a growing thread of developer complaints paints a very different picture. Issue #42796 on the Claude Code repository documents widespread frustration with the tool's reliability for complex engineering tasks. Developers report that updates degraded the tool's ability to handle multi-step workflows, maintain context across large projects, and produce consistent results in the kind of iterative development work that defines most professional software engineering.
The contrast is striking but not contradictory. Finding a vulnerability in a single file, even a deeply hidden one, is a focused analytical task. Building and maintaining software across interconnected systems over time is a fundamentally different kind of work. Claude Code appears to excel at the former while struggling with the latter, and that distinction matters enormously for how we think about AI's role in professional development.
Why Focused Brilliance Doesn't Equal Reliable Engineering
The vulnerability discovery and the usability complaints reveal a core limitation in how current AI coding agents work. Tasks with clear boundaries, like scanning a file for security flaws, play to the strengths of large language models: pattern recognition, broad knowledge of known vulnerability classes, and the ability to reason about code semantics within a defined scope.
Professional engineering is messier. It involves maintaining state across sessions, understanding project-specific conventions, navigating dependency chains, and making judgment calls that depend on organizational context no model has access to. When developers in the GitHub thread describe Claude Code as "unusable for complex engineering tasks," they're pointing at this gap between analytical capability and sustained, context-rich collaboration.
This isn't unique to Claude Code. Every AI coding tool on the market faces some version of this problem. But Anthropic's tool is a useful case study because of its prominence and because the company has been unusually transparent about its capabilities. Ars Technica described Claude Code's early 2025 launch alongside Claude 3.7 Sonnet as a command-line AI agent in limited research preview. The model introduced "extended thinking," a chain-of-thought reasoning mode that let users allocate up to 128,000 tokens for the model to work through problems step by step. This was a direct response to reasoning models from OpenAI, Google, and DeepSeek.
Extended thinking made Claude Code genuinely better at certain tasks. But more tokens for reasoning don't solve the fundamental challenge of maintaining coherent intent across a multi-hour development session involving dozens of files and shifting requirements. That's a systems problem, not a reasoning problem.
The Source Code Leak and What It Reveals About Tool Maturity
Compounding Anthropic's challenges, the company accidentally exposed Claude Code's source code through an npm source map file, InfoQ reported. The leak itself is a fairly common type of operational mistake in software distribution, but it carries extra weight here. Developers trusting an AI agent with access to their codebases and development environments need confidence that the tool's own infrastructure is buttoned up.
The incident also offered a rare look under the hood. Claude Code, like most agentic AI tools, is fundamentally a loop: collect user input, execute function calls, pass results back to the language model, repeat. The architecture is straightforward. The value proposition rests almost entirely on the underlying model's capability and the quality of the orchestration layer that manages context, permissions, and tool use.
This frames the competitive dynamics correctly. As we explored in our earlier coverage of Anthropic's Cowork launch, the agentic AI wrapper itself isn't a deep technical moat. Open-source alternatives like OpenCode have attracted significant user bases, and the real differentiation comes from model quality, context management, and ecosystem integration. When Claude Code's orchestration layer degrades, as the GitHub complaints suggest, the tool's value proposition erodes fast.
The On-Device Push and Why It Matters Here
The timing of these Claude Code growing pains coincides with a broader industry shift toward on-device AI processing. Apple, Google, Qualcomm, and others have been investing heavily in running AI models locally on phones, laptops, and edge devices rather than routing everything through cloud APIs.
For coding tools specifically, on-device processing addresses several pain points that cloud-dependent agents like Claude Code face. Latency drops dramatically when the model runs locally. Privacy concerns diminish when source code never leaves the developer's machine. And perhaps most importantly, local models can maintain persistent context about a project without the token-window constraints and session-reset issues that plague cloud-based tools.
The tradeoff is capability. On-device models are necessarily smaller and less powerful than the cloud-hosted models that power tools like Claude Code. You're not going to run the equivalent of Claude 3.7 Sonnet with extended thinking on a laptop's neural engine anytime soon. But for many of the routine engineering tasks where Claude Code is reportedly struggling, like navigating familiar codebases, applying consistent patterns, and maintaining context across sessions, a smaller but always-available local model might actually perform better in practice.
This creates an interesting strategic split. Cloud-based agents may end up specializing in the kinds of focused, high-capability tasks where they shine, like Carlini's vulnerability hunting. Meanwhile, on-device models could handle the steady-state development work where consistency and context matter more than raw reasoning power.
What This Means for Anthropic's Business
Claude Code's trajectory carries real business implications. The tool hit $1 billion in annualized revenue after just six months, as we noted in our coverage of Anthropic's Cowork strategy. That's extraordinary growth, but it also means Anthropic has a lot to lose if developer trust erodes.
The Cowork product, which extends Claude Code's agentic capabilities to non-developers for general office tasks, represents Anthropic's attempt to broaden its addressable market. But if the core developer tool is generating usability complaints on GitHub, expanding to less technical users seems risky. Non-developers have even less tolerance for inconsistent behavior than engineers do.
Anthropic's competitors aren't standing still. GitHub Copilot continues to deepen its integration with Visual Studio Code and the broader GitHub ecosystem. Google's Gemini models are being woven into Android development workflows. And the open-source ecosystem keeps growing, offering developers the flexibility to swap underlying models without changing their tooling.
The source code leak adds another dimension. Enterprise customers evaluating AI coding tools weigh security posture heavily. An accidental exposure of the tool's own source code, however minor in technical impact, creates a narrative problem for a company asking developers to grant its agent deep access to proprietary codebases.
Where This Goes Next
The current state of AI coding tools resembles the early days of cloud computing, when the technology was clearly transformative but the specific products were unreliable enough to make adoption a calculated bet. Claude Code can do things that would have seemed like science fiction two years ago. It can also fail at tasks a competent junior developer handles without thinking.
The resolution likely involves specialization. Rather than one tool that handles everything from vulnerability research to routine refactoring, we're probably heading toward a landscape where different AI tools, running in different environments, handle different kinds of work. Cloud-hosted models with massive context windows tackle analysis and discovery. On-device models handle day-to-day coding assistance with lower latency and better project awareness. And the orchestration layer, the part that decides which model to call and how to manage context, becomes the real product differentiator.
For developers, the practical takeaway is straightforward: treat AI coding tools as powerful but narrow collaborators, not as replacements for engineering judgment. Claude Code's ability to find a 23-year-old Linux kernel vulnerability is remarkable. Its inability to reliably handle multi-step engineering workflows is a reminder that remarkable and reliable are different things.
For Anthropic, the path forward likely requires acknowledging that gap publicly and investing in the orchestration and context-management layers that make the difference between a demo and a daily driver. The model underneath is clearly capable. The product around it needs to catch up.
