Anthropic published their 2026 Agentic Coding Trends Report this week. The headline numbers are extraordinary: 95% of developers use AI tools at least weekly. 75% use AI for more than half their engineering work. 56% say they're doing 70% or more of their work with AI.
For context: GitHub Copilot launched in 2021. Five years later, nearly every developer is using some form of AI in their daily workflow. This is one of the fastest technology adoption curves in software history.
But here's the question the numbers don't answer: are 95% of developers using AI well? Because from where I sit — watching how engineers actually use these tools — the answer is clearly no. And the gap between using AI and using it well is larger than most people realise.
Two Types of AI User
Two distinct types of AI user have emerged, and the difference isn't which tool they use or how much. It's the mental model they bring to it.
The first type treats AI like a better autocomplete. They ask it to write a function, review what it produces, tweak it, move on. They're faster for it. But their usage is reactive: something needs to be written, so they ask AI to write it. The AI handles the typing. The developer still does all the thinking.
The second type treats AI like a collaborator they're directing. Before they write anything, they talk through the approach. They describe constraints. They ask the agent to identify what could go wrong. They review the plan before the code. The AI handles execution. The developer handles judgment, direction, and review.
The TELUS data from the report makes this concrete: teams using Claude Code shipped 30% faster and saved over 500,000 hours — averaging 40 minutes saved per AI interaction. That's not what you get from better autocomplete. That's what you get from genuine agent-level collaboration.
What the Productive Users Actually Do Differently
They work at the task level, not the line level
The average autocomplete user says: 'write me a function that does X.' The productive user says: 'I'm building a system that does Y. Here's the constraint set. Here's what already exists. I need to add Z — think through the approach and tell me what tradeoffs we're making before you write anything.' The AI response to the second prompt is qualitatively different.
They treat the first draft as a starting point, not a result
AI-generated code is often syntactically correct, logically plausible, and subtly wrong for your specific situation. The most productive users expect this and build review into their process. They run the output, check edge cases, ask the agent what it assumed. The users getting burned are the ones who assume correctness and only find out later.
They use AI to think, not just to write
Some of the highest-value uses of these tools don't produce a single line of code. 'Here's the architecture I'm considering — what are the failure modes?' 'I've hit this error three times. Talk me through what might be causing it.' 'Review this PR diff and tell me what a senior engineer would flag.' These prompts generate insights that make the next hour of work more effective.
The shift to make
Stop asking AI to write code. Start asking AI to think with you before you write code. The second approach takes slightly longer up front and produces dramatically better output.
The 56% Number Worth Being Careful About
56% of developers report doing 70%+ of their engineering work with AI. That sounds impressive. It might also be a warning sign for some of those developers.
There's a version of that number that means: 'AI handles the routine work and I focus on judgment calls, architecture decisions, and review.' That's excellent. There's another version that means: 'I mostly accept what AI produces without deeply understanding it.' That's a debt accumulation strategy that eventually comes due.
Engineers who can't read AI-generated code critically — who can't explain why it works, catch when it doesn't, or articulate the tradeoffs it made — are building on foundations they don't understand. The experienced engineers who've seen this play out have a consistent warning: use AI aggressively for speed, but never let it get ahead of your understanding.
The Four Skills That Actually Compound
- Prompt design: writing precise, constraint-rich prompts that produce useful first drafts rather than generic code requiring heavy editing.
- Critical review: reading AI output with genuine scepticism, checking assumptions, identifying edge cases the model optimised around.
- Task decomposition: breaking work into AI-solvable units and reasoning about which parts need human judgment before, during, and after generation.
- Context management: understanding how to give AI the right context — not everything, not nothing — to get responses that fit your actual situation.
“The ceiling for developers who use AI well has risen dramatically. The floor for developers who use it carelessly is lower than they think.”
The Uncomfortable Implication
The 95% adoption number means AI tool usage is no longer a differentiator. Everyone's using it. Differentiation now comes from how well you use it — and that's a skill most developers have barely started developing deliberately.
The good news: the gap between median and excellent usage is large and closeable. Pick one interaction pattern to get genuinely good at — prompting for code review, architecture discussion, test case generation — and practise it deliberately for a month. Then add the next. The developers who make this shift explicitly rather than waiting for it to happen naturally are the ones next year's productivity data will be written about.