Every week someone on Twitter claims AI made them a "100x developer." They built a landing page in 10 minutes. They scaffolded an API in an hour. They're shipping "at the speed of thought."

I've been using AI coding tools heavily for eight months. Here's my honest assessment of the actual multiplier, task by task.

Where AI Gives You 10x

Boilerplate code. CRUD endpoints, form components, data models, migration files. Anything that follows a pattern you've established, AI writes in seconds. I used to spend 30 minutes on a new API endpoint with tests. Now it's 3 minutes. That's a real 10x.

Test writing. AI is excellent at generating the first 80% of a test suite. Edge cases, boundary conditions, error paths. I still add the last 20% manually, but the time savings are enormous. Writing tests went from the task I dreaded to the task I barely think about.

Code comprehension. Reading unfamiliar code used to take hours of tracing through files. Now I ask Claude to explain a module, trace a data flow, or map the dependencies. Understanding a new codebase went from days to hours.

Mechanical refactoring. Renaming a concept across 40 files, extracting a shared utility, converting callbacks to async/await. These tasks are tedious but straightforward, and AI handles them almost perfectly.

Where AI Gives You 2-3x

Feature development. Building a real feature still requires understanding the requirements, making design decisions, and handling the integration points. AI speeds up the implementation phase but doesn't help much with the thinking phase. On a feature that takes me 4 hours, AI saves maybe 1.5 hours. Good, but not 10x.

Debugging complex issues. AI can help narrow down the search space, suggest hypotheses, and check assumptions. But the hard bugs, the ones involving timing, state management, or cross-system interactions, still require human reasoning. AI is a good assistant here, not a replacement.

Code review. AI catches obvious issues quickly, but the high-value review feedback (architectural concerns, long-term maintainability, domain-specific correctness) still comes from experienced humans. AI as a first-pass reviewer saves time but doesn't replace the human reviewer.

Where AI Gives You 1x (No Improvement)

Architecture decisions. Choosing between a monolith and microservices, deciding on a data model, designing a system that will scale. These decisions require understanding business context, team capabilities, and long-term tradeoffs. AI can list pros and cons, but the decision still requires human judgment that understands the full context.

Requirements gathering. Talking to stakeholders, understanding what they actually need versus what they asked for, and prioritizing work. AI has nothing to contribute here.

Debugging production issues at 2 AM. When a service is down and customers are affected, the diagnosis requires access to monitoring dashboards, deployment logs, and the ability to make judgment calls about rollbacks. AI doesn't have access to most of this context and works too slowly for an incident response.

Where AI Makes You Slower

Yes, this happens.

Over-relying on AI for tasks you know well. If I can write a simple utility function in 30 seconds, asking AI to do it takes longer because I have to describe what I want, wait for the response, and verify it. For very small, well-understood tasks, just typing is faster.

Reviewing bad AI output. When the AI generates code that's subtly wrong, reviewing it takes longer than writing it myself would have. You read the code, it looks plausible, you accept it, and then you find the bug later. The debugging time exceeds the writing time.

The Honest Math

If I look at my actual work distribution: about 30% of my coding time is boilerplate and mechanical tasks (10x improvement), about 40% is feature development and debugging (2-3x improvement), and about 30% is architecture, planning, and communication (1x or less).

Weighted average: I'm roughly 3-4x more productive overall. On my best days, with the right tasks, it feels like 10x. On days full of meetings and architecture discussions, AI barely moves the needle.

That's still transformative. A 3-4x improvement in productivity is life-changing. But it's not 100x, and anyone claiming 100x is either measuring the wrong things or hasn't worked on hard problems yet.

What Actually Makes You Fast

The developers getting the most out of AI share three traits:

They're already good. AI amplifies existing skill. If you can't recognize good code, you can't verify AI output. If you don't understand the architecture, you can't give clear instructions. The better you are, the more AI helps.

They're specific. Vague prompts produce vague results. Fast developers write precise instructions that get right answers on the first try.

They know when not to use AI. The fastest developers I know use AI for 60-70% of their coding, not 100%. They know which tasks benefit from AI and which are faster by hand. That judgment is the real multiplier.