On this page

Related reading

← RCF

Concept

What is the 80/20 flip in AI coding?

In January 2026, Andrej Karpathy described a shift from roughly 80% manual coding to 80% agent-written code within weeks. Requirements and verification account for more of the remaining engineering work.

Last updated

The 80/20 flip describes Karpathy’s shift from roughly 80% hand-written code to 80% agent-written code in a few weeks. Agents took over most code writing. Human decisions and verification became most of the remaining work.

Where does the term come from?

From a post Karpathy wrote on 26 January 2026. He described moving from about 80% manual and autocomplete coding in November to 80% agent coding with 20% edits and touch-ups by December, and called it the biggest change to his coding workflow in around two decades of programming.

The figures described his own workflow, not a benchmark. Other engineers recognised a similar change in their work. The term became shorthand for that shift.

What actually flipped?

Code authorship and effort allocation changed. In this framing, code writing fell from 80% of build effort to 20%. Deciding what to build and verifying it rose from 20% to 80%. The total work did not shrink.

The eighty-twenty flip A before-and-after comparison of where engineering effort goes, shown as two vertical bars of identical total height. Before AI: 80 percent of effort was typing, writing code, generating boilerplate, hand-rolling docs, and only 20 percent was the hard engineering work: requirements, acceptance criteria, architecture, review, traceability. After AI, the proportions invert: 20 percent typing, 80 percent the hard stuff. The total work is the same. The weighting flipped. The hard-stuff segment, shown in burnt orange, is the part where engineering value actually lives, it was always there, just hidden by the bulk of typing. Before AI: 80% of engineering effort spent on typing: writing code by hand, generating boilerplate, hand-rolling documentation. Visible work that masked everything else. 80% Typing Before AI: only 20% on the hard stuff: requirements, acceptance criteria, architecture, traceability, review. The part most organisations quietly skimped on because the typing hid it. 20% The hard stuff After AI: 20% on typing. AI does the code, the boilerplate, the docs. The visible bulk of the old job collapsed. 20% Typing After AI: 80% on the hard stuff. The thinking, the structure, the discipline. Same activities, same scope; now load-bearing because the typing isn't masking them. The engineering, as distinct from the coding. 80% The hard stuff
Same work. Inverted weighting.

Karpathy described agent mistakes as conceptual errors rather than syntax errors. Agents can make incorrect assumptions while producing code that compiles and reads well. Assessing those assumptions remains an engineering responsibility.

Why does the flip matter?

Most engineering organisations still organise hiring, review and completion criteria around code writing. Those practices need to reflect the new distribution of effort.

Producing code faster than the team can understand it causes AI drift. Mistaking rapid initial progress for a nearly complete product creates the gap described in demo-ready versus production-ready. The last twenty percent describes the remaining engineering work and its production consequences.

What does the flip mean for methodology?

As code generation becomes cheaper, requirements, acceptance criteria and verification account for more of the work.

RCF defines acceptance criteria as the contract before code is written. The five-stage build cycle separates review from generation. Traceability links code to its business decisions. Across two years of the author’s projects, code writing became cheaper and these practices took a larger share of effort, while total effort remained similar.

Karpathy changed his workflow within weeks. Organisations will take longer. Adjusting engineering practices before a backlog accumulates helps retain the productivity gain.