How I Use Claude Code and Coding Agents Without Becoming Useless

Here's the uncomfortable finding I keep coming back to. In early 2025, METR ran a proper randomized controlled trial: 16 experienced open-source developers, working on repositories they'd spent years in, doing 246 real tasks. Half the tasks let them use AI tools, half didn't. Before it started, they expected AI to make them about 24% faster. Afterward, they reported it had made them roughly 20% faster.

The stopwatch said they were 19% slower.^[1]

Sit with that gap for a second. These weren't juniors flailing with a new toy. They averaged about five years on the exact projects they were working on. And they were wrong about their own productivity by nearly 40 percentage points, in the wrong direction. The tool felt fast. The work got slower. That gap between how it feels and what actually ships is the whole subject of this piece, because that gap is where your job either survives or quietly disappears.

Autocomplete is a trap, and it's a popular one

Let me be clear about what I'm not saying. I'm not saying put the agent down. I use Claude Code every day and I'm not giving it back. Claude Code went from a billion dollars in annualized run-rate revenue around November 2025 to over 2.5 billion by February 2026, with weekly active users roughly doubling since the start of the year.^[2]That is not a fad. It's one of the fastest-scaling developer tools ever built, and it's scaling because it genuinely works.

What I'm saying is that there are two completely different ways to use one of these things, and they lead to two completely different careers. Anthropic's own Economic Index splits usage into automation, where you hand off a whole task, and augmentation, where you work a problem out with the model. On the consumer Claude.ai app it's almost even, 49% automation to 51% augmentation. On Claude Code it's 79% automation to 21% augmentation.^[3]The coding surface is overwhelmingly people saying “go do this” and walking away.

Delegation isn't the trap. Blind delegation is. If you treat the agent like a slightly smarter tab-complete, accepting diffs because they look plausible and compile, you've volunteered to be the part of the pipeline that adds nothing. A model can generate plausible code. What it can't do yet is own the consequences of that code being wrong at 2am in production. That ownership is the job. It was always the job. The typing was never the job.

The value moved to verification, so I moved there too

Dig into that 79% automation number and something interesting shows up. Anthropic classified the automation interactions further: 43.8% are “directive,” minimal human involvement, fire and forget. But 35.8% are a “feedback loop,” where the human validates work the agent completed.^[3]Read that again. Even inside the most hands-off way people use these tools, more than a third of the value is a person checking the output. The verification didn't go away when the generation got automated. It became the main event.

That matches what the accountable people actually feel. The 2025 Stack Overflow survey, over 49,000 developers across 177 countries, found 84% use or plan to use AI tools, up from 76% a year before. But only about 29% trust the accuracy of the output, and that number fell from roughly 40% the year prior.^[4]Adoption up, trust down. The more people used it, the less they trusted it, which is exactly what you'd expect from people who've been burned by confident, wrong code.

And here's the tell. The most experienced developers are the most skeptical group in the whole survey. Their “highly trust” rate is around 2.6%. Their “highly distrust” rate is near 20%.^[4]The people most on the hook for shipping code verify the hardest. That's not fear of the tool. That's knowing what it costs when something slips through.

The bottleneck didn't vanish, it moved downstream

This is the part that should scare anyone shipping to production. The 2025 DORA report found roughly 90% of developers now use AI in their workflow, and yes, it improves throughput. More code, faster. But AI adoption still shows a negative relationship with delivery stability, because code volume is growing faster than review and deployment systems can absorb it.^[5]

The numbers people pulled from that data are brutal. Median time a pull request spends in review rose 441%. Average PR size grew 51.3%. Thirty-one percent more PRs merged with no review at all. Bugs per developer rose 54%. Incidents per PR rose 242.7%.^[6]Generation got cheap, so we generated more, and all that extra work piled up at the one station that didn't get automated: a human understanding whether the change is correct.

If you're looking for where to be indispensable, it's written right there in the failure data. Be the person who shrinks the PR instead of ballooning it. Be the review that actually happened. Be the reason an incident didn't. None of that is about typing faster. All of it is about judgment the model doesn't have.

How I actually run the loop

So concretely, here's how I work now, shaped entirely around not falling into the 19%-slower hole.

• I only delegate what I could verify.If I don't understand the problem well enough to check the answer, I don't hand it to the agent, because I'd just be laundering my confusion into code that looks finished. The agent is a force multiplier on judgment I already have, not a substitute for judgment I don't.
• I read every diff like I'm reviewing a stranger's PR. Not skimming for red squiggles. Actually reading it, asking what happens at the boundaries, what it does under concurrency, what it silently swallows. The METR devs reported spending real time cleaning up AI output rather than shipping it directly.^[1] That cleanup isn't overhead. It's the work.
• I keep PRs small on purpose.The tool wants to hand me a 600-line change. I break it down, because a PR nobody can review is a PR that ships bugs, and the DORA data says that's exactly what's happening at scale.^[6]
• I use it most where I'm strongest, not weakest. Counterintuitive, but the places I know cold are where I can move fastest with an agent, because verification is instant. In unfamiliar territory it just feels fast while quietly costing me time, which is the exact illusion the study measured.
• I stay in augmentation for anything hard.For the 20% of problems that are actually tricky, I don't fire and forget. I work it out with the model, keep my hands on the wheel, and treat its output as a strong first draft I'm editing, not an answer I'm accepting.

The part that isn't abstract

I want to be honest about the stakes, because there's a real labor story underneath all this and it's not evenly distributed. A Harvard study tracking about 62 million workers across roughly 285,000 U.S. firms from 2015 to 2025 found that junior employment at AI-adopting companies fell 9 to 10% within six quarters of adoption. Senior employment stayed essentially flat.^[7] The floor is getting pulled out, not the ceiling.

And it shows up in the hiring data. Job postings for entry-level developers fell roughly 60% between 2022 and 2024. By July 2025, employment for software developers aged 22 to 25 was down nearly 20% from its late-2022 peak, with unemployment for tech workers aged 22 to 27 running around 7.4% against a national average near 4.2%.^[8] The job that's disappearing fastest is the one that was mostly about producing code under supervision. That's the job the agent does now.

I don't say that to be grim. I say it because it points straight at what to do. The skill that's appreciating is the one that used to be the senior half of the job: knowing what to build, catching what's wrong, owning what ships, connecting the code to the thing the business actually needs. If you're early in your career, the move isn't to out-type the agent. You can't. It's to sprint toward judgment, review, systems thinking, the stuff that reads as senior, as fast as you possibly can. Use the agent to build that judgment faster, by reading its output critically instead of accepting it.

The bet I'm making

Here's where I land. The agent isn't the threat and it isn't the savior. It's a lever. A lever multiplies whatever force you put into it, including zero. Point good judgment at a coding agent and you get a genuinely faster, sharper engineer. Point no judgment at it and you get the METR result: someone generating a lot of plausible code, feeling productive, and quietly shipping slower and buggier than they would have alone.

The developers who get replaced over the next few years won't lose to the AI. They'll lose to the developers who used the AI to become more valuable, while they used it to become interchangeable. Same tool, opposite outcomes, and the only variable is whether you kept doing the hard human part or let the tool convince you it was handled.

So I read the diffs. I keep the PRs small. I delegate what I can verify and I stay hands-on with what I can't. I let the agent do the typing and I keep the judgment, the review, and the ownership firmly mine. That's not caution. In a world where generating code is nearly free, that's the entire job.