AI Learned All Our Code and None of Our Judgment

A post making the rounds on dev.to argues that LLMs have read essentially all open code on GitHub but never learned the thing that matters: the reasoning behind it. Models see finished buildings, never the arguments in the architect's office. The proposed fix: train on full commit histories instead of final snapshots, so models absorb how code evolves rather than what it looks like when it's done.

The diagnosis is right, and it's measurable. The prescription, though, was tried almost three years ago — and the results tell us something more uncomfortable about where the real gap is.

The judgment gap shows up in the data

This isn't a vibes argument anymore. Three independent measurements, three different methodologies, one direction.

GitClear analyzed 211 million changed lines across 2020–2024 and found that duplicated code blocks (five-plus copied lines) increased eightfold during 2024, while refactored and moved code — the signature of someone tending an abstraction — fell from roughly a quarter of changed lines in 2021 to under 10%. 2024 was the first year in their dataset where copy/paste exceeded moved code. That's the statistical fingerprint of a tool that generates plausible code but doesn't reuse what already exists, multiplied across an industry.

Google's DORA research found that a 25% increase in AI adoption correlated with a 7.2% drop in delivery stability and a 1.5% dip in throughput — more code shipped per change, more of it coming back to bite.

And METR ran the study everyone should sit with: a randomized controlled trial where 16 experienced open-source maintainers completed 246 real tasks on their own repositories. With AI tools (mostly Cursor with Claude 3.5/3.7 Sonnet), they were 19% slower — while believing the AI had made them 20% faster. Experienced developers working in codebases they know deeply are exactly the population whose value is judgment rather than typing speed. The tools helped least where tacit knowledge mattered most.

We already fed models the commit histories

Here's where the popular prescription falls apart. Training on git history isn't a frontier idea — it's prior art. BigCode's OctoPack work built CommitPack back in 2023: 4TB of git commits across 350 languages, pairing diffs with commit messages precisely to teach models how code changes, not just how it ends up. It produced better instruction-following code models. It did not produce engineering judgment.

Nor is process data missing in the broader sense. The best-documented deliberation in software history — the Linux kernel mailing list, pgsql-hackers, decades of Python PEPs and Rust RFCs — is public, crawled, and in every frontier model's training set. These models have read more architectural argument than any human engineer alive. The judgment gap persisted anyway.

That should update our theory of the problem. Reading about judgment doesn't produce judgment, in models or in people. Michael Polanyi's line about tacit knowledge — "we know more than we can tell" — cuts deeper here than the commit-history crowd allows: the knowledge that makes a senior engineer senior was never written down anywhere, because it can't be. It's acquired by shipping the clever abstraction and maintaining it for two years. It lives in consequences, not descriptions.

Consequence is the missing training signal

The one place models have genuinely improved at engineering — not just code generation — is where labs stopped feeding them text and started feeding them outcomes. Modern coding agents are trained with reinforcement learning against real repositories: attempt the fix, run the tests, get rewarded when they pass. That's a consequence loop, and it's why agents can now resolve real GitHub issues that stumped models two years ago.

But look at the reward horizon. Test suites deliver their verdict in seconds. The consequences that constitute engineering judgment — the abstraction that calcifies, the dependency that becomes a supply-chain liability, the schema decision that makes every future migration hurt — pay out over months and years. No current training loop reaches that far, and it's not obvious how one could. That, not missing git logs, is the actual frontier, and it's why I'd bet the judgment gap outlives the next several model generations even as benchmark scores keep climbing.

What this means for your team, concretely

If judgment can't be trained in yet, it has to be supplied from outside the model. Teams are already converging on this without naming it: every AGENTS.md, every Cursor rules file, every CLAUDE.md is an attempt to convert a team's tacit knowledge into explicit context. That practice — writing down why your codebase is shaped the way it is, which patterns are load-bearing, what "done" means here — is the highest-leverage AI investment most teams can make, and it doubles as onboarding docs for humans. The agents.md convention exists precisely because the models can't infer this and everyone quietly knows it.

Beyond that, the data suggests three unglamorous moves. Watch duplication and churn in your own repos, because GitClear's eightfold clone growth means your reviewers are the last line of defense against copy-paste debt an assistant will happily generate. Keep changes small — DORA's stability hit is consistent with AI inflating batch size, and batch size is something you control. And treat review as the design gate, not the syntax gate: the model can produce a correct diff, but whether that diff should exist is exactly the question it can't answer.

The dev.to post ends hoping commit-history training turns AI from imitator into engineer. I'd frame it differently: the imitator is genuinely useful, the engineer is still you, and the empirical record says teams that forget the distinction ship less stable software while feeling more productive. The perception gap in the METR study — slower while feeling faster — is the sharpest warning in the whole dataset. Judgment was always the hard part of this job. For now, it still doesn't compress.