Skip to main content
← /writing

Over and Over Again

The 10,000-hour rule counted hours, and we now count merged pull requests. Skill comes from feedback at the edge of your ability, and agents take it out of the work unless you design it back in.

Vinny Carpenter15 min read2.9k words

never the stack · audio edition

Over and Over Again

21:12

In 2008, Malcolm Gladwell's "Outliers" gave the world a number. He called 10,000 hours "the magic number of greatness," and the popular reading followed. Practice anything that long, it said, and mastery arrives. The number spread because it's generous. It says the gap between you and an expert is time, and anyone can spend time.

The researcher behind the number spent years correcting it. Gladwell drew on a 1993 study of Berlin violin students by Anders Ericsson, Ralf Krampe, and Clemens Tesch-Römer. Ericsson later said Gladwell had "misinterpreted some of our findings." The 10,000 hours was a group average at age 20, and half of the best violinists hadn't reached it. The practice Ericsson measured was also a specific kind. Students worked alone on a weakness a teacher had identified, at the limit of what they could do.

Other researchers cut the claim down further. A 2014 meta-analysis by Brooke Macnamara and colleagues pooled 88 studies. Deliberate practice explained 26% of the variation in performance in games, 21% in music, and less than 1% in professions. A 2019 replication of the violin study found that the best players had logged no more practice than the good ones. What survives is narrower than the rule and more useful. Nobody in that argument thinks skill arrives without practice. Ericsson's point was that the hours only counted when each attempt reached past what the student could already do and drew feedback.

I have my own history with the generous version. On Dec. 31, 2025, I published a post about getting better at getting better, with a card near the top. The card set consistency against intensity, progress against perfection, and fundamentals against fads. It ended on four words: over and over again. Then I spent 2026 handing a lot of the "over and over" to agents.

Addy Osmani named the problem in August, in an essay on what he calls agentic skill decay. One of his headings states the argument: "A completed task is not necessarily a rep." The person who ran the agent may come away knowing nothing new. He aims his advice at individuals, mostly people early in their careers, and it's good advice. I want to push the argument toward two groups he leaves alone: senior engineers and the organizations that employ them.

Skill comes from feedback at the edge of what you can do. Agents multiply output and take that feedback out of the work, so teams have to design and budget the practice that once came free.

I've spent most of this year arguing that judgment is what's scarce once agents make implementation cheap. Judgment is what practice leaves behind. If the practice goes, the supply of judgment goes with it, and no amount of throughput replaces it.

A merged PR counts the way an hour counts

We're repeating Gladwell's mistake with a new unit. Hours were easy to count, so the rule counted hours. Merged pull requests and closed tickets are easy to count, so we count those.

Ericsson made this point about Gladwell's best-known example. Gladwell counted the Beatles' Hamburg club shows as practice hours. Ericsson answered that playing for a crowd is performing, and a performance doesn't target a weakness. Merging a pull request is a performance too.

My own numbers make the case. On Saturday, Oct. 31, I merged 64 agent-written pull requests across three repos between 9:30 and 11:38 a.m. That's 128 minutes, or two minutes per merge on average. One of them, PR #650, carried a finding from Codex, an automated reviewer, that a shared message could lose its body text. I merged it in a batch anyway. Feedback only becomes practice if you stop for it, and at two minutes a merge I didn't.

The morning showed me where the work had moved. With agents handling implementation, my part was to define the work clearly and to decide whether the result was ready for users. I'd practiced the first in the kickoff document and skipped the second at the merge. Verification and release capacity have to keep pace with implementation, and someone has to resolve every meaningful review finding before the code lands. That accountability stays with a person, however much autonomy the agents get.

A randomized trial by Judy Hanwen Shen and Alex Tamkin, published by Anthropic, shows the same thing under controlled conditions. The study had 52 developers, mostly junior, learn an unfamiliar Python library. The group with an AI assistant scored 50% on the quiz that followed. The group that coded by hand scored 67%. The hand-coding group also hit more errors along the way. The authors suspect that resolving those errors built the debugging skill the AI group lacked. The AI group finished about two minutes faster, a gap too small to be statistically significant.

How people used the assistant mattered as much as whether they had it. Developers who delegated the coding averaged below 40%. Developers who asked conceptual questions and wrote the code themselves averaged about 65%. The tool and the task were the same in both cases. The people who kept doing the thinking kept the skill.

A rep, as I'll use the word here, is one attempt at the edge of your ability, followed by feedback you have to act on. An hour can hold several reps or none. So can a merged PR.

Experience expires without practice

The practice that kept engineers sharp was a byproduct of the work, and agents remove it for senior people as well as new ones. In August I argued that entry-level work had two outputs: the shipped feature and the capability the person gained by shipping it. I called the second one accidental apprenticeship, because nobody designed it. That essay was about the on-ramp. The same byproduct kept experienced engineers current, and it's disappearing at every level.

Lisanne Bainbridge described the mechanism in 1983, in a short paper on industrial process control called "Ironies of Automation." Automate the routine work, she observed, and the operator's skills deteriorate from lack of use. When the automation fails, the person who has to take over is out of practice at the moment the job is hardest.

Anthropic's June study of about 400,000 Claude Code sessions adds a detail that should bother anyone with a senior title. It rated expertise per task, so a senior engineer asking a first question in an unfamiliar language rates as a beginner. Sessions rated novice reached verified success about 15% of the time. Sessions rated intermediate or higher reached it 28% to 33% of the time. In that data, expertise belongs to the task in front of you, and a title doesn't transfer it.

I made a version of this argument about leaders in Still in the Code. A leader's technical judgment expires faster now, and building firsthand is how I keep mine calibrated. That essay mentioned a sync bug, and the rest of the story shows what calibration looks like.

Earlier this year, rebuilding GSD, my task manager, for iPhone, iPad, and Mac exposed an assumption in my sync engine. GSDSync used the device's clock to decide which updates to request from the server. A clock running ahead could make it skip changes, which left a completed task missing on another device with no error. Working through the failure on real hardware brought me back to a basic question: whose clock was deciding what counted as new?

The fix moved the sync cursor to server timestamps, and a regression test captured the failure. The package's test suite ran in under a second, which made that behavior cheap to check as the app changed. Building the app also gave me a sharper question. When someone tells me sync works, I ask what happens when the devices disagree about time.

I've also written about a rule of three. The first version teaches you the problem, the second teaches you the design, and the third is the one you meant to write. An agent can now produce all three in a morning. The versions still get written. I'm less sure who learns from them, because the agent starts its next session without the lesson unless someone writes it down.

Some reps should retire

The best argument against all of this is that skills are supposed to expire. Few working engineers practice assembly, and the industry is better for it. Every rise in abstraction retires a set of skills, and I've called AI a new abstraction layer.

The research gives the skeptic more to work with. In the 2014 meta-analysis, deliberate practice explained less than 1% of performance differences in professions, the category closest to ours. Its authors concluded that deliberate practice is "important, but not as important as has been argued." I take that seriously. The authors suggest deliberate practice is harder to define in professional work, which may explain the low number. Still, the finding measures how well logged practice hours rank peers against each other. It doesn't test what happens to a skill when practice drops to zero, and full delegation creates that condition.

So the useful question is which reps to keep. My test comes from Bainbridge. Keep the reps for the work that lands on you when the agent is wrong. Today that means specifying what done means, verifying that the result meets it, and diagnosing a failure the agent can't explain. The sync bug was that third kind of rep. Syntax recall and boilerplate can go, and I won't miss them. The list will keep shrinking as agents improve, and the test will stay the same.

The evidence is thinner than I'd like

I'm arguing from a small evidence base, and a careful reader should know how small. The Anthropic trial had 52 people, one library, and a quiz taken minutes after the task. The usage patterns I cited come from groups of four to seven people. The authors say they can't tell whether the gap predicts long-term skill. The session study found most of the gain between novice and intermediate, with a modest step from there to expert. The skill needed to supervise agents may be lower than I think, and cheaper to reach.

What would change my mind is a study showing that people who only ever reviewed agent output verify as well as people who built first. I haven't seen one. My own evidence is one person's side projects, which makes it an anecdote.

Build the rep into the agent's work

A rep in agent-driven work is a prediction you make before the agent's output, checked against what comes back. The agent can still do the typing. What the person has to keep is the attempt and the feedback. In August I laid out moves like this for apprentices, and the first was to frame the problem before the agent generates anything. That move applies to a principal engineer the same way, and I use it myself.

I keep part of the specifying rep in the specification review, before any implementation. I describe the behavior I expect, then work through the questions Claude raises. On one settings feature, my first pass had a single acceptance criterion: change the setting and save it. I hadn't worked through malformed values, save failures, or accessibility behavior. The review exposed those omissions.

I also read and approve the failing test before a separate builder agent implements the change. Later reviews caught an accessibility gap and a mismatch with the acceptance criteria. The feedback reached both the code and my understanding of the feature. My first definition of done had been too small, and the review made me account for what I'd missed.

Claude supplied the feedback in that review. That fits the Anthropic trial, where the developers who asked questions kept the skill. An agent takes the feedback out of the work when I delegate the thinking. It can put feedback back when I ask for the questions first.

The rep also has to leave something in the system, because the agent forgets. Osmani's test is that practice should leave both the engineer and the agent better off. My evidence is the standards file I described in From Copy-Paste to Skill. Each time I corrected an agent, I wrote the correction down as a rule, and the file grew from about 40 lines to about 400. A correction I don't write down has to be made again in the next session.

I count a rep as finished when two things are true. I can explain what I got wrong, and the system has a test or a rule that would catch it next time. The sync bug meets that standard.

A rep in agent-driven work: predict the behavior you expect, let the agent do the typing, and check it against what comes back.

image description

A rep in agent-driven work: predict the behavior you expect, let the agent do the typing, and check it against what comes back. The rep is finished when you can explain what you got wrong and a test or a rule would catch it.

Verifying is the rep PR #650 tested. A week later I ran a second sprint and gave the lead agent, which coordinates the worker agents, more responsibility for merging. The lead required written reviews, and the web repository could block a merge while a review conversation stayed unresolved. When that gate stopped the lead, it waited while authors addressed findings and I resolved the threads.

But another web change still merged with a valid Codex finding unaddressed, and the original share bug stayed open. My account merged that change outside the lead's sequence. I had built a review process that didn't govern every route to main. The next requirement is that blocking findings get addressed and checks cover the revision that will land, whoever performs the merge. That includes me. By the standard I just described, this rep is still open.

Three reps to keep.

image description

Three reps to keep. Specifying what done means, caught in a specification review. Verifying that the result meets it, still open after PR #650. Diagnosing a failure the agent can't explain, where the GSDSync clock bug meets the standard.

Give practice a line in the budget

Individuals can't fix this alone, because the pressure to skip the rep comes from the delivery system. If throughput is the only thing a team reports, the two-minute merge wins.

Start by separating daily workflow reps from dedicated calibration time. Spec reviews, failing-test approvals, and resolving blocking findings belong inside normal feature delivery, even when they slow down the two-minute merge. Those reps are the cost of shipping safely.

On top of daily reps, teams need protected time to practice in unfamiliar systems. In Where the Saved Hour Goes I argued that leaders have to decide what AI's time savings are for. Part of that dividend, I wrote, belongs to deliberate practice. I've done the event version of this. In May 2025, I kicked off an internal hackathon on generative AI and agents. The brief asked people to share their progress, failures included. Learning from the attempt was part of what we wanted them to contribute.

A hackathon happens once. The step I'd take now is to put that same intention into regular capacity planning. I'd reserve two hours per engineer each sprint for practice in unfamiliar systems and reduce delivery commitments to account for them. Each session would have a real problem, a prediction made up front, and feedback from a colleague. If an incident displaced the time, we'd reschedule it. As the leader, I'd own the conversation about which delivery work moved to make that practice possible.

I don't have a proven measure for those two hours. The daily reps are easier to count. I'd start with blocking review findings that merge unresolved, the count PR #650 put on my record, and check it after a quarter.

Then change what gets asked. A rollup can show 100% goal coverage while the goals sit untouched, which I learned writing my own transition plan. The question I'd add to every review is where this person got feedback at the edge of their ability this quarter. If the answer is nowhere, the dashboard is counting hours.

Let the platform absorb toil and leave the learning to engineers

Finally, look at the platform, because it's already teaching your engineers. In September I argued that the best AI developer experience repairs the failures the platform owns. For failures in a developer's code, it only proposes a fix. I drew that line for ownership, and it's the right line for learning too. A registry timeout is toil, and nobody gets better by reading its logs. A failure in your own code is practice, and the fix should arrive after you've made your own diagnosis.

Gladwell later said that practice was never a sufficient condition for success. I think his rule got the patience right, because skill still takes years of attempts. It got the unit wrong. I still have the card from that December post. I'd add a clause to its last line: over and over again, with something telling me what I got wrong.

found this useful? share it

Post on X Share to LinkedIn
Vinny Carpenter

Written by Vinny Carpenter

VP Engineering · 30+ years building software

I lead engineering teams building cloud-native platforms at a Fortune 100 company. I write about engineering leadership, AI-assisted development, platform strategy, and the hard lessons that come from shipping at scale.

keep reading