Seventy-five percent.
That’s the number Anthropic’s CEO Dario Amodei dropped in early 2025. He said AI could be writing 75% of all code within the next year or two. Maybe more.
The internet lost its mind.
Developers flooded forums with questions. Students panicked about their career choices. Business owners started wondering if they still needed to pay for development at all. Tech journalists ran with the headline like it was a verdict.
But here’s the thing — that number is real. And it’s also wildly misunderstood.
There’s a massive difference between “AI generates 75% of code tokens” and “AI is doing 75% of a developer’s job.” Those two statements sound similar. They mean completely different things. And the gap between them is where most of the confusion — and most of the anxiety — lives.
This post unpacks the actual claim. What does 75% of code even mean? Where does that number come from? What parts of development does AI genuinely cover? And what does none of this change about why skilled developers still matter?
No panic. No false comfort. Just the clearest picture we can give you of what’s actually happening.
Where Did the 75% Figure Actually Come From?
The number didn’t come from a research paper. It came from a conversation.
Dario Amodei, CEO of Anthropic, mentioned in a public discussion that AI could soon be writing around 75% of all code. He framed it as a near-future projection — not a current measurement, not a peer-reviewed finding.
Other tech leaders have made similar claims. In late 2024, Google CEO Sundar Pichai revealed that over 25% of new code at Google was already being generated by AI. That number was notable but significantly lower than 75%.
GitHub’s own data from Copilot usage shows that AI-generated suggestions account for a meaningful percentage of accepted code in active repositories. But “accepted suggestion” is not the same as “AI wrote the program.”
So where does 75% come from exactly? It’s a projection. An estimate. A signal about trajectory, not a measurement of today’s reality.
The honest context: AI code generation is growing fast. The percentages being quoted are directionally real. But they measure lines of code or accepted tokens — not replaced developers, not eliminated judgment calls, not automated thinking.
That distinction matters enormously.
What Does “75% of Code” Actually Mean?
This is where most people’s understanding breaks down.
When someone says AI is writing 75% of code, they’re typically talking about code tokens or accepted suggestions — not complete programs.
Think about what a developer does in a day. They write function signatures. They type out repetitive loops. They scaffold boilerplate files. They generate standard CRUD operations. They write comments and docstrings. They produce test stubs.
A lot of that work is pattern-based. It follows conventions that AI has seen a million times in training data. Copilot can autocomplete a standard React component faster than you can type it. It can write a SQL query from a plain English comment. It can generate a CSS class you’ve used a hundred times.
That’s the 75%. The structural, repetitive, convention-following material.
What’s in the other 25%? The thinking. The problem framing. The architecture decisions. The debugging of subtle logic errors. The judgment calls about what to build at all. The communication with clients about what they actually need versus what they asked for.
It’s like saying a GPS does 75% of driving. In one sense, maybe — it handles route calculation, turn-by-turn instructions, traffic rerouting. But you’re still the one watching the road, reacting to the car that just swerved, deciding whether to stop for petrol, and figuring out what to do when the GPS sends you down a one-way street.
The 75% is real. It’s also not the part that makes a developer irreplaceable.
How AI Code Generation Actually Works in Practice
Understanding what AI does technically helps you understand why the 75% stat is both impressive and limited.
Large language models like Claude, GPT-4, and the models powering GitHub Copilot are trained on enormous amounts of public code. They learn patterns — how functions are typically structured, what comes after a class declaration, how a React hook is usually implemented.
When you type a comment like // function to filter products by price range, the model predicts the most statistically likely code that follows. It doesn’t reason through the logic like a developer would. It pattern-matches from training data.
This works remarkably well for common, well-documented patterns. Standard CRUD endpoints. Common sorting algorithms. Typical form validation logic. These are highly represented in training data. The model has seen them thousands of times.
It works poorly for: unusual business logic, undocumented system constraints, novel architectural problems, code that interacts with custom or proprietary systems, and anything where “correct” depends on context the model doesn’t have.
AI code generation is essentially a very smart autocomplete. Insanely useful. Genuinely impressive. But it predicts, it doesn’t understand. That difference matters the moment you leave well-trodden territory.
The Real Productivity Shift Happening Right Now
Here’s what the 75% conversation is actually pointing at: developer productivity is changing dramatically.
GitHub’s research showed developers using Copilot completed tasks 55% faster on average. That’s not marginal. That’s a fundamental shift in how much one developer can output in a day.
What this means practically:
A developer who used to spend three hours writing boilerplate for a new feature now spends 45 minutes. The time saved goes toward harder problems — architecture, testing edge cases, reviewing logic, refining user flows.
A junior developer can produce production-quality code faster because the AI handles the syntax layer they’d normally struggle with. They can focus on understanding the logic rather than getting stuck on implementation details.
A senior developer becomes significantly more leveraged. They can review and direct more AI-generated code than they could ever write manually. One experienced developer’s judgment now scales across a much larger volume of output.
This is the real story behind the 75% number. It’s not “AI is doing developers’ jobs.” It’s “developers are becoming significantly more productive with AI assistance.” Those are different narratives with different implications.
And here’s the uncomfortable truth for anyone hoping AI does all the work: faster output without strong judgment just means producing wrong things faster. The human in the loop isn’t optional — it’s what determines whether the 75% AI generates is actually any good.
Which Types of Code AI Handles Well vs. Poorly
Not all code is equal. AI handles some categories extremely well and others very badly. Knowing the difference makes you a smarter developer and a smarter buyer of development services.
AI handles well:
- Standard CRUD operations (create, read, update, delete)
- Boilerplate file and project structure generation
- Common algorithms — sorting, searching, filtering
- Unit test scaffolding for well-defined functions
- CSS and HTML from design descriptions
- SQL queries from plain English descriptions
- Documentation and code comments
- Converting code between similar languages or frameworks
- Refactoring for readability on simple functions
AI handles poorly:
- Novel business logic with unusual requirements
- Debugging race conditions and asynchronous edge cases
- Performance optimization requiring deep system understanding
- Security-sensitive code where subtle errors have serious consequences
- Architecture decisions affecting long-term scalability
- Integration with undocumented or proprietary APIs
- Code that must account for specific client or user context
- Anything requiring judgment about product direction, not just implementation
The pattern is clear. AI excels at well-defined, pattern-based, heavily-documented territory. It struggles at the edges — the novel, the contextual, the consequential.
As the old saying goes: a river finds the path of least resistance. AI code generation flows easily through familiar channels. It struggles when the terrain is unmapped.
What Google’s 25% and Anthropic’s 75% Tell Us Together
These two numbers — Google’s current 25% and Amodei’s projected 75% — tell a story about trajectory.
Google is one of the most sophisticated engineering organisations on the planet. Their developers are elite. Their codebases are complex. Their tooling is state of the art. And even there, 25% of new code comes from AI.
That 25% isn’t busywork. Google’s developers aren’t writing trivial code. They’re building systems of enormous complexity. So if AI is already contributing meaningfully at that level, the 75% projection isn’t implausible over a longer timeline.
But notice what Google didn’t say. They didn’t say AI is making developers redundant. They didn’t reduce their engineering headcount by 25% because AI writes 25% of code. The productivity gain went into faster shipping, more ambitious features, and higher output per engineer.
The 75% projection from Amodei should be read the same way. It’s a statement about how much of the typing and structural generation AI will handle. It’s not a statement about decision-making, product thinking, architecture, or the human judgment that determines whether any of it actually works for users.
Taken together, these numbers describe a world where developers write less repetitive code and do more high-level thinking. That’s not a threat to the profession. For most developers, that’s actually an improvement.
How Developers Are Adapting Their Workflow Right Now
The developers who are thriving in this shift aren’t the ones debating whether AI is good or bad. They’re the ones who figured out how to work with it effectively.
Here’s what smart adaptation looks like in practice.
Using AI for first drafts, not final answers. Generate the function, review it critically, modify where needed. Treat AI output like a junior developer’s contribution — useful starting point, not trusted production code.
Investing in prompt skill. Writing effective prompts is a real skill. Vague prompts produce vague code. Specific, contextual prompts produce useful starting points. Developers who communicate clearly with AI tools are significantly more productive than those who don’t.
Deepening review capability. If AI writes more of the first draft, the critical skill becomes reviewing code quality, catching subtle errors, and understanding why something works — not just that it works.
Specialising in what AI can’t do. System architecture. Client consultation. Complex debugging. Security review. Performance optimisation. These areas are getting more valuable, not less, as AI handles more of the commodity work.
Building knowledge, not just output. The developers who lean too hard on AI without understanding what it generates are building a fragile skillset. The moment they face an AI-free environment or an edge case the AI handles badly, they’re stuck. Strong fundamentals still matter — maybe more than ever.
The WordPress Development Angle Nobody’s Talking About
WordPress powers a massive slice of the internet. And the AI conversation hits differently in the WordPress ecosystem.
AI tools are absolutely entering WordPress development. There are AI plugins for content generation, image optimisation, SEO suggestions, and layout recommendations. Page builders including Elementor are adding AI-assisted design features. Theme generators are getting smarter.
Does that mean AI is writing 75% of WordPress code? In some template-heavy, low-complexity builds — probably. A standard five-page business site using a common theme and standard plugins? AI can scaffold most of that.
But here’s what that doesn’t cover.
Custom plugin development for specific business workflows. WooCommerce configurations that match complex inventory and pricing rules. Performance optimisation for a WordPress site handling serious traffic. Security hardening against current threats. Headless WordPress architectures that connect to external applications.
And then there’s the client layer. The conversation where you understand what a business actually needs. The discovery phase where you figure out why their current site isn’t converting. The strategic decisions about what to build versus what to integrate.
At WordPress Baba, the work that matters most to clients isn’t code generation. It’s knowing what to build, building it correctly, and making sure it works for real users with real goals. AI can assist parts of that process. It can’t lead it.
What the 75% Number Means for People Learning to Code
If you’re learning to code right now — or thinking about it — the 75% stat probably feels unsettling. Let’s address that directly.
Learning to code in 2026 is still worth doing. The argument isn’t that you’ll spend your career typing every line manually. The argument is that understanding what correct code looks like is what allows you to work with AI effectively.
Think of it like learning to cook. You still need to know when the sauce is wrong — even if you’re using a food processor for half the prep. The judgment that says “this function has a race condition” or “this architecture won’t scale beyond 1000 users” comes from understanding. Not from typing.
The developers who will struggle aren’t the ones using AI. They’re the ones who used AI as a crutch during learning and never built the underlying understanding. They can generate code but can’t explain it, debug it, or adapt it under pressure.
The right approach: use AI tools from day one as learning accelerators. Let Copilot show you how something can be written. Then close it and write it yourself from memory. Understand why, not just what. Build real projects where you have to debug things that broke for non-obvious reasons.
That combination — strong fundamentals built with AI-assisted learning — produces developers who are genuinely ready for the current market.
Should Businesses Worry That AI Is Doing 75% of Development Work?
If you’re a business owner or product leader, here’s the practical read on the 75% figure.
AI tools are making development faster. That’s mostly good news for you. Projects that used to take four weeks might take three. Features that needed a senior developer can sometimes be scaffolded with AI and reviewed by a mid-level engineer.
But faster code generation creates its own risks if the human layer thins too much.
AI-generated code that isn’t reviewed carefully can ship with security vulnerabilities, performance problems, or logic errors that only surface under load. The 75% AI generates still needs the 25% human judgment to be safe, correct, and maintainable.
The businesses best positioned for this shift are those working with developers who use AI tools well — not those trying to replace developers with AI tools directly.
What does “use AI well” look like from a hiring perspective? Ask candidates to explain code they’ve written, not just show it. Ask how they review AI-generated output. Ask where they’d trust AI and where they’d write from scratch. The answers reveal whether they’ve built genuine expertise or just learned to prompt.
The Bigger Shift: From Code Writers to Code Directors
Here’s the frame that makes the most sense of everything happening.
The role of the developer is shifting from code writer to code director.
In the old model, a developer’s value was partly in their speed and volume of output. How many features can you ship per sprint? How fast can you implement this component?
In the new model, the value is in judgment. What should be built? How should systems be structured? Is this AI-generated code actually correct and safe? What tradeoff does this architecture create? How does this decision affect the product three years from now?
Those questions were always the important ones. They’re just becoming more visibly important as AI handles more of the typing layer.
Think of it like the transition from manual accounting to spreadsheets. Accountants didn’t disappear. Their role shifted from doing the calculations to directing them — asking the right questions, setting up the right models, interpreting the outputs. The tool got more powerful. The human judgment sitting on top of the tool became more valuable, not less.
The 75% is the spreadsheet doing the maths. The developer is still the accountant deciding what to calculate and whether the answer actually makes sense.
What Comes After 75%: The Trajectory Forward
If AI is projected to write 75% of code soon, what comes after? Is 100% inevitable?
This is worth thinking about clearly rather than emotionally.
Generating more code tokens is probably achievable. AI models are improving rapidly. The percentage of boilerplate, standard patterns, and well-defined implementations that AI handles will likely keep growing.
But there are structural limits to how far that substitution goes.
Software requirements come from human context. A business’s needs, user behavior, market conditions, regulatory requirements, performance constraints — these are human realities that have to be translated into technical decisions. That translation requires human understanding.
Edge cases are infinite. Every codebase develops unique quirks, technical debt, undocumented behaviors, and integration dependencies. AI has no memory of your codebase’s history. It doesn’t know why a particular function was written the way it was four years ago.
Accountability is non-delegable. When a system fails in production, someone is responsible. That accountability requires human judgment throughout the development process — not just at the end.
The honest projection: AI will handle progressively more of the structural, repetitive, pattern-based work. The human role in development will concentrate increasingly around judgment, architecture, communication, and oversight. Both the human and AI contributions will grow in absolute terms as more software gets built overall.
100% AI-generated code, unsupervised? That’s not where this is going. More like a world where one developer, working with strong AI tooling, can do what previously required a team.
Conclusion
So is AI really pushing 75% of code?
In terms of token generation and accepted suggestions in AI-assisted workflows — probably. Trending that way, at least. The Amodei projection isn’t noise. It’s directional signal.
But that number describes the typing layer of development. It doesn’t describe the thinking layer. And the thinking layer is where the actual value of software development has always lived.
AI writes the scaffold. Developers decide what to build, verify it’s correct, handle the parts that don’t fit the pattern, and take responsibility for what ships. That’s not a diminished role. For developers who lean into it, it’s a more interesting role than before.
The 75% story isn’t about replacement. It’s about leverage. One good developer with AI tools can now do more than was previously possible. That changes the economics. It raises the bar for what “entry level” means. It shifts what skills matter most.
What it doesn’t do is make human judgment, system thinking, client communication, and deep technical expertise obsolete. Those things are getting more valuable in a world where everyone has access to fast code generation.
At WordPress Baba, we pair experienced human judgment with the best available development tools — AI-assisted where it helps, expert-directed always. If you need a web presence built with real thought behind it, not just generated code:
📞 +880 1886-465676 📧 contact@wordpressbaba.com