AI doesn't create great developers, it amplifies them

Bill Doerrfeld · article · 2026-01-20 source ↗ Reader 🖥️

AI as Amplifier Code Quality Measuring AI Impact Talent Density

The apparent productivity gap between heavy and light AI users is mostly a selection effect, not a treatment effect of AI itself — the developers getting the most out of AI coding tools were already the most productive developers the year before, so AI amplifies pre-existing talent rather than creating new talent, and leaders should stop using general AI adoption as a performance proxy.

practical · argumentative — A trade-press article reporting and interpreting a GitClear/GitKraken industry study (~30,000 datapoints, 2,000+ developers, late 2024–late 2025), aimed at engineering leaders. Argumentative in structure (uses the data to argue against a specific wrong inference — 'AI creates great developers') and practical in upshot (how leaders should and shouldn't use AI-adoption metrics).

Structure

Part	Role
Cross-sectional finding: power AI users show 4-10x higher output metrics (Diff Delta, commits) than non-users	evidence (the tempting but misleading headline finding)
Longitudinal finding: the same developers' output grew only ~12% (regular users) to ~81% (power users) year-over-year, while non-users' output was flat to slightly down	evidence (the corrective finding that reframes the cross-sectional one)
Mechanism: senior/experienced developers already 'see the bigger picture' and prompt more effectively, so they extract more value from the same tools	explanation
Caveat: higher AI-driven output quantity correlates with more code duplication, churn, and review time, even though these side effects scale linearly rather than explosively	qualification
Methodological lesson: comparing AI-user cohorts to non-user cohorts mostly measures who your best developers already are, not AI's causal effect	conclusion

Key terms

Diff Delta
GitClear's proprietary measurement of meaningful lines of code changed — explicitly distinguished from raw line counts as a proxy for 'durable' (lasting, non-churned) code changes.
Amplifier (framing)
AI's effect is multiplicative on existing developer capability/behavior rather than additive or creative — it scales up whatever a developer already does well (or poorly), rather than installing new capability in someone who lacked it.
AI usage cohort
GitClear's grouping of developers by how heavily they interact with AI coding tools (non-user through power user), used as the unit of both the (misleading) cross-sectional comparison and the (corrective) longitudinal comparison.

Propositions

explicitPower AI users show roughly 4-10x higher Diff Delta and commit counts than non-users in a cross-sectional comparison, which in isolation would suggest AI itself makes developers dramatically more productive.conf: high
explicitThe same cross-sectional gap, examined longitudinally for individual developers over a year, shrinks to a 12% output increase for regular AI users and 81% for power AI users, while non-users' output changed by a statistically insignificant amount (about -2%) — meaning most of the cross-sectional gap predates AI adoption.conf: high
explicitDevelopers who moved into heavier AI usage were already among the highest performers the prior year, which constitutes selection bias: top performers increasingly concentrate in the AI-heavy cohort over time, inflating that cohort's average while depressing the non-AI cohort's average — independent of any causal AI effect.conf: high
supportsMeasuring AI impact, assessing readiness, and new data trends · p3 — Both pieces independently (different vendors/studies — GitClear here, DX there) reach the identical methodological conclusion: cross-sectional AI-usage-vs-productivity comparisons are confounded because heavy AI users were already the highest performers, so longitudinal tracking of the same individuals is required to isolate AI's actual effect.
supportsSWLW #710: Revised rules of Eng Leadership, When AI costs more than the engineer, and more. · p5 — This article's central finding — AI amplifies whichever developers were already strong, rather than creating new strength — is a concrete empirical instance of the general 'amplification is a magnitude, not a direction' thesis.
explicitSenior/experienced developers are better positioned to extract value from AI tools because they already know what good code looks like and can prompt more effectively, and empirically 'the most senior developers have been the most voracious adopters.'conf: high
explicitHigher commit quantity from AI use does not necessarily translate into higher end value: independently, CodeRabbit's research found AI-generated PRs contain 1.7x more issues than human-written PRs, with business-logic/control-flow correctness issues up 75% and performance issues (e.g. excessive external calls) up 8x.conf: medium
explicitIncreased AI code output correlates with increased code duplication, review time, and churn, but these negative side effects scale roughly linearly with output rather than exploding faster than output — and AI power users actually require marginally less review time relative to the volume of durable code they deliver.conf: medium
supportsSoftware Design in the Agentic Age: Place Your Bets · p4 — Both observe the same quality-at-scale pattern: as AI-driven code volume grows, the absolute amount of downstream maintenance burden (duplication/churn/review time here; production issues there) grows too, even when the relative or per-unit quality picture looks acceptable or improving.
explicitAs AI adoption grows, the performance gap between high and low performers is likely to widen rather than close, because AI compounds a pre-existing advantage rather than leveling the field.conf: medium
explicitComparing broad AI-user vs. non-user cohorts on productivity metrics mostly measures who an organization's most effective developers already are, not AI's causal impact — so leaders should not use general AI adoption as a proxy for individual performance, and should instead look at what top performers using AI are actually doing well.conf: high
supportsTechnology Radar, Volume 34 · p10 — Both make the same methodological warning: measuring AI-assisted development success by raw output metrics (lines of code, commits, PR counts) in isolation is misleading and can itself distort behavior, rather than revealing AI's true causal contribution.

Arguments

Leaders should not treat AI adoption intensity as a performance signal, and should not expect AI to close skill gaps between developers. strength: high

Explicit premises:

Cross-sectional AI-user vs. non-user comparisons show large gaps.
Longitudinal tracking of the same individuals shows those gaps mostly predate AI adoption.
The developers who adopted AI most heavily were already the highest performers the year before.

Implicit premises:

GitClear's own metric (Diff Delta, 'durable code changes') is an adequate stand-in for genuine developer value/performance, not merely a quantity proxy — despite the article itself later conceding that higher commit quantity doesn't necessarily translate into higher end value and that AI-generated code tends to carry more defects.

Inferences:

If the selection-bias explanation is right, AI adoption programs aimed at closing the gap between weaker and stronger developers (rather than concentrating further investment in already-strong ones) will likely underperform expectations, because the mechanism the data identifies is amplification of existing skill, not skill transfer.

Questions addressed

✅ Are all developers equally more productive when given AI coding tools?
No — the productivity gain is highly uneven and strongly correlated with prior performance level; non-users showed essentially flat output year-over-year.
⭕ Why do senior/experienced developers get more value from AI tools than others?
Offered only as a plausible mechanism (better big-picture understanding, more effective prompting, prior code-quality judgment) rather than demonstrated with direct evidence from this study — asserted via an interview quote, not measured.
✅ Does more AI-driven code output come with a proportionally worse maintenance burden?
Partially: duplication, review time, and churn all increase with AI output, but the article reports these scale linearly rather than explosively, and reports power users face marginally less review time relative to their output volume than mid-tier users do.

Gaps

incompleteThe article asserts a mechanism (senior developers 'see the bigger picture' and 'prompt more effectively') for why AI amplifies seniority, but the underlying GitClear study as described only measures output metrics (Diff Delta, commits, PRs) longitudinally — it does not report any direct measurement of prompting behavior, code review quality, or 'big picture' understanding that would actually test the proposed mechanism rather than merely restate the correlation in explanatory language.
Read next: Research that directly measures prompting strategy or decision quality (rather than output volume) across experience levels would be needed to confirm the proposed mechanism rather than just the correlation.
incompleteThe piece treats the amplification finding as roughly static ('it's best to assume it's amplifying pre-existing talent') without asking whether deliberate organizational investment — structured onboarding, pairing juniors with power users, AI-specific training — could shift who ends up in the 'power user' cohort over time, i.e. whether the selection effect it documents is itself a lever leaders could pull rather than a fixed fact about who benefits from AI.
Read next: Corpus material on junior-hiring economics and systemic apprenticeship in the AI era directly engages whether and how the talent pipeline that feeds 'power users' can be deliberately grown rather than assumed to be fixed.