Experience Isn't Years. It's Surprises: How Developers Actually Get Better With AI
Two developers fix the same bug with the same AI. Only one gets better. Here's the mechanism, and the one-sentence habit that fixes it.
Here's a small scene. Users in Tokyo see their appointment dates one day early, but only for bookings made late at night. Two junior developers pick up the ticket.
The first pastes the bug report into an AI assistant, applies the fix, and closes the ticket in minutes.
The second writes one line before asking anything: "I think it's the date format string." She's wrong. The server stores timestamps in UTC, and 00:30 in Tokyo is still the previous day in UTC. The display code was formatting the UTC date.
Same fix, same green tests. Only the second developer got better at the next bug. That difference is what this article is about.
Key Takeaways
Experience isn't years or output. It's the number of times your mental model of a system was wrong and you found out why.
Learning happens in a four-step loop: guess, run, surprise, update. The surprise (prediction error) is the part that rewires your instincts.
AI's real cost isn't doing the work for you. It's letting you skip the guess. No guess means nothing can be wrong, so nothing updates.
The evidence agrees: in Anthropic's 2026 trial, juniors who used AI scored 50% on a follow-up quiz versus 67% without it, with the biggest gap in debugging. But those who asked "why" scored 65% or higher.
Used well, AI speeds experience up, because checking a guess now takes seconds instead of hours.
The fix costs under a minute: guess before you prompt, predict before you run, study the gap, explain the fix back, keep a surprise log.
Why "years of experience" was always a proxy
Job ads ask for three to five years because years used to track something real. You couldn't ship code without getting stuck, and you couldn't get unstuck without learning. Time and struggle rose together.
AI broke that link. You can now ship a lot of working code while rarely getting stuck. Which raises the question of what the number on your CV was measuring in the first place.
Years of experience was never the point. It was a rough count of how many times you were wrong and found out why.
The experience loop: guess, run, surprise, update
Every useful learning moment in software has the same shape:
Guess. You expect something about what the code does or what's broken.
Run. Reality answers.
Surprise. The answer doesn't match your guess.
Update. You work out why, and your picture of the system gets more accurate.
Learning science calls step three prediction error: the gap between what you expected and what happened, which the brain uses to decide what's worth remembering.
A senior engineer's "smell" for bugs is this loop, compressed. When someone says "that's a timezone thing" before reading the stack trace, they're drawing on a library of old wrong guesses.
What AI actually removes from the learning loop
The usual claim is that AI makes juniors worse because it does the work. More precisely, it removes step one. Paste the error before forming a guess, and there's nothing for reality to contradict. The loop doesn't close badly; it never opens.
AI didn't take your reps. It took the guess that made them count.
The trap is that green tests feel identical whether you understood the fix or not. You find out what was missing only when a bug arrives that the AI can't solve.
What the research says about AI and junior developer skills
In a randomised trial published by Anthropic in early 2026, 52 mostly junior engineers learned Trio, an unfamiliar Python async library. Half used an AI assistant. On the follow-up quiz, the AI group averaged 50% and the hand-coding group 67%, with debugging showing the largest gap. The AI group wasn't significantly faster.
How people used the assistant mattered more than whether they used it. Wholesale delegation and AI-driven debugging averaged below 40%. Asking follow-up questions, requesting explanations, or using AI only for concepts scored 65% or higher. Every one of those high-scoring habits keeps the guess, and the gap, alive.
Why AI can make you gain experience faster
Before AI, the slow step in the loop was feedback: an afternoon of docs and print statements to find out if your guess was right. AI makes feedback nearly instant. Guess first, and you can close far more loops in a week than was possible when every answer cost an afternoon.
The bottleneck used to be feedback. Now it's your willingness to be wrong on purpose.
The real divide isn't AI users versus non-users. It's people who treat AI as an answer machine versus people who treat it as a fast referee for their own guesses.
Five habits to build debugging experience while using AI
1. Guess before you prompt. One sentence: what's wrong, and why. Vague is fine.
2. Predict before you run. State the expected output, then check it.
3. Study the gap, not the answer. When the AI disagrees with you, ask why your guess was wrong.
4. Explain the fix back. If you can't say why it works, you aren't done.
5. Keep a surprise log. One line per wrong guess. Reread monthly.
FAQ
Does using AI make junior developers worse at coding?
It can, depending on how it's used. In Anthropic's 2026 trial, juniors using AI scored 50% on a comprehension quiz versus 67% without it, with the biggest gap in debugging. But participants who asked follow-up and conceptual questions scored 65% or higher. The habit matters more than the tool.
What is "experience" for a software developer, really?
A useful definition is the number of times your mental model of a system was wrong and you found out why. Years are a proxy for that count, and AI has made the proxy much less reliable.
How can junior developers build debugging skills in the AI era?
Form a guess before asking AI, predict outputs before running code, focus on why your guess differed from the answer, explain every fix in your own words, and keep a log of wrong guesses to review monthly.
Is it bad to paste error messages straight into ChatGPT or Claude?
Not inherently, but pasting before you've formed any hypothesis skips the step where learning happens. Write one sentence about what you think is wrong first; then the AI's answer becomes feedback on your thinking instead of a replacement for it.
Can AI help developers learn faster?
Yes, if you guess first. AI makes checking a hypothesis take seconds rather than hours, so you can close far more learning loops per week than was possible before, provided you keep putting a prediction on the table.
Do senior developers lose skills from relying on AI?
There's less direct evidence for seniors, but debugging instinct is a procedural skill, and procedural skills tend to get rusty without practice. The same guess-first habits apply at every level.
Related reading
The bottom line
Experience isn't years and it isn't output. It's corrected guesses. AI can shrink that count to zero or multiply it, and the difference is one sentence you write before you hit enter.
A career is not the code you shipped. It's the model of the world you built while shipping it.
Adam Jaber is a software engineer who writes Simply Explained: complex topics, made simple. No jargon, no hype.
