The 90% That’s Going to Zero (And the 10% AI Can’t Touch)

Why Ten Years of Coding Made You More Replaceable Than a Fresh Graduate

Kent Beck, the father of Extreme Programming, said something that silenced the entire industry:

"90% of my skills have gone to zero in value. The remaining 10% have had their leverage amplified a thousandfold."

Can you tell which of your skills belong to that 90%, and which belong to the 10%?

You Think You're Accumulating, but You're Actually Depreciating
There's a deeply entrenched belief in programmer circles: the more experience you have, the more valuable you are. Ten years in, you can recite frameworks by heart, write APIs with your eyes closed, and your Notion is filled with every pitfall you've ever stepped into. That's your "age moat."

But Kent Beck's words are brutal: that is precisely the 90% that is going to zero.

Let me break down this recursive depreciation chain for you:

Information Retrieval → Code Writing → Heuristic Accumulation → Positional Advantage

These four layers have formed the entire logic of "age-based value appreciation" for programmers over the past two decades.

Layer 1: Information Retrieval. You spent three years memorizing hundreds of Spring Boot annotations, React lifecycle hooks, and common Linux commands—knowledge that once had a barrier because looking things up was slow, documentation was sparse, and Stack Overflow hadn't yet taken over. What about now? Research on GitHub Copilot (arXiv:2302.06590) shows that AI-assisted programming increases coding speed by 55%. The APIs stored in your brain can be retrieved by AI in 0.2 seconds. This isn't "acceleration"; it's equalization. A decade of memory advantage has been compressed to zero.

Layer 2: Code Writing. You spent five years honing your CRUD speed, design pattern combinations, and debugging intuition—and AI already writes code faster than you. More painfully, the Google DORA 2024 report found that a 25% increase in AI usage did accelerate code review speed, but simultaneously, the change failure rate rose by 7.2%. AI is indeed helping you write code, but your ability to review what it produces hasn't grown alongside it. Aaron Yong precisely captured this asymmetry in a 2026 analysis: "The cost of writing code has collapsed; the cost of reading code hasn't budged. This asymmetry changes everything."

Layer 3: Heuristic Accumulation. You say, "I've stepped into a thousand pitfalls; that's experience." But METR's 2025 research delivers a stinging slap: experienced developers using AI perceived their speed as having increased by 20%, while their actual speed slowed down by 19%. Why? Because they've accumulated too many "old heuristics": lessons that no longer apply in the AI era and have instead become cognitive burdens. You think your heuristics are appreciating, but they're actually expiring. It's like an old taxi driver who spent years memorizing which intersections have traffic cameras—the navigation system knows all of it now. Your accumulation has become redundancy.

Layer 4: Positional Advantage. You've been at the company for eight years. You know the architecture, you know which modules are heaps of legacy spaghetti, you have a silent understanding with the product manager—these "irreplaceable contexts" do have real value. But GitClear's 2025 report, which analyzed 211 million lines of code, found that code duplication has soared tenfold in the AI era, code churn has doubled, and the proportion of refactoring has plummeted from 25% to under 10%. What does this mean? AI is producing code that "looks like it runs but that nobody understands" at an unprecedented rate. Your positional advantage is being drowned in comprehension debt—the systems you once knew are becoming just as unfamiliar to you as they are to a newcomer.

The old logic of "age-based appreciation" was: the more you accumulate, the more valuable you become. AI has shattered this equation. What you've accumulated happens to be exactly the 90% that is depreciating.

What Exactly Is That 10%?
If 90% is going to zero, what is the remaining 10%?

What Kent Beck referred to is architectural taste—which breaks down into a fusion of three abilities: alignment, decomposition, and judgment.

Alignment: Can you understand what the product manager truly wants, as opposed to what they said? Can you translate business requirements into system constraints, instead of mechanically turning a PRD into JIRA tickets? A large-scale field study in IEEE TSE (78 developers, 3,148 hours tracked) found that developers spend 58% of their time understanding code, and only 22% writing it. Comprehension—understanding what people mean, reading a system—is the real bottleneck. AI writes code very fast, but AI doesn't understand the "why."

Decomposition: Faced with a complex problem, can you break it down into sub-problems that are truly independently solvable? This is far harder than it sounds. Yourdon and Constantine proposed the Fundamental Theorem of Software Engineering back in 1978:

C(P) > c(½P) + c(½P)

It means: the cost of solving a problem is always greater than the sum of the costs of solving its two halves separately—unless those two halves can genuinely be solved independently. AI accelerates the execution of "splitting," but the decision cost of "should we split" hasn't budged. Split wrongly, and the interface costs will devour all the benefits. The real-world case of the Amazon Prime Video team is a bloody lesson: they moved back from distributed microservices to a monolith and saved 90% of their costs. The interface complexity introduced by the split far outweighed the deployment flexibility it provided.

Judgment: Among ten possible technical approaches, choosing the right one. Rich Hickey, the creator of Clojure, made a piercing distinction in 2011: Simple vs. Easy.

Simple = untangled. The inherent complexity of the problem is cleanly separated.

Easy = near to us. Something you're familiar with, already know, and can do without learning anything new.

AI tends to give you Easy, not Simple. Because it samples from training data, and your existing codebases contain far more shallow modules than deep modules (John Ousterhout's core insight in A Philosophy of Software Design). Shallow modules have complex interfaces and simple implementations (think of that Utils class you've seen with 20 methods); deep modules have simple interfaces and complex implementations (think of the Unix file system—four interfaces: open, read, write, close—with an entire kernel underneath).

AI-generated code naturally leans toward shallow modules, because the training data is full of them. The ability to distinguish Simple from Easy demands precisely the one thing no shortcut can provide: time. You have to have seen enough shallow modules turn into mountains of legacy spaghetti to instinctively reject Easy and pursue Simple. This isn't something you learn by reading a book; it's muscle memory refined through a decade of stepping on landmines.

Ox Security analyzed 50 pieces of AI-generated code across 300 open-source projects and concluded: "Functionally complete, but systematically lacking in architectural judgment." Functionally complete—that 90% of execution skills, AI has already taken over for you. Architectural judgment—that 10%—it cannot do.

AI Has Torn Away the Disguise
Here comes the turning point.

Before AI, the 90% and the 10% were blended together. A programmer with eight years of experience had their CRUD speed and architectural judgment packaged into one, looking like an "experienced engineer." Execution-layer skills masked the difference in the judgment layer—because you could write code fast, everyone assumed you could also make decisions fast.

After AI, the 90% has been equalized.

Copilot, Cursor, Claude—these tools have shrunk the gap between a fresh graduate and an eight-year veteran in "writing code" to nearly zero. GitHub's own research has proven this: a 55% increase in coding speed, and it's an across-the-board increase, regardless of how many years you've been at it.

But the 10% has been stripped bare.

When execution is no longer the bottleneck, judgment becomes the single remaining dimension of differentiation. You will see a polarization: those with strong judgment use AI as a multiplier, amplifying their output a thousandfold; those with weak judgment use AI as an adder, producing more but at lower quality, manufacturing comprehension debt even faster.

This isn't theoretical; it's already happening. Anthropic's own research (arXiv:2601.20245) found that groups using AI assistance coded at the same speed as the control group but scored 17% lower on comprehension tests (50% vs. 67%). Speed didn't increase, but understanding actually decreased. Why? Because they outsourced their thinking to AI without developing the judgment to verify its output.

Addy Osmani, Director of Engineering for Chrome, coined a term in 2026: "Comprehension Debt." "AI code looks clean, passes linting, but comprehension debt accumulates invisibly." Every line of code that "runs but no one truly reads" is a pitfall dug for your future self. A March 2026 study by Professor Storey's team further systematized this issue, proposing a "Three-Debt Model": technical debt in the code, cognitive debt in the human brain, and intent debt in the documentation. The three debts form a vicious cycle: technical debt makes code harder to understand, insufficient understanding leads to missing documentation of intent, missing intent makes modifications more dangerous, and dangerous operations create even more technical debt. AI has supercharged this cycle at extreme speed.

Kin Lane, a 35-year veteran in the API space, said a now-widely-quoted line: "I've never seen so much technical debt created in such a short period of time."

Ana Bildea, a tech executive, described an even more extreme case: her team went from fully embracing AI to "from acceleration to completely unable to ship" in under 18 months. The reason was exactly that the 90% of execution skills were hyper-amplified by AI, but the 10% of judgment hadn't kept pace—AI-generated code grew like weeds, and nobody could judge which should stay, which should be cut, and which would come back to bite you.

An agent is a multiplier, not an adder. This mathematical fact changes everything: a multiplier amplifies what you already have. If what you already had was primarily execution skills (the 90%), amplified, you get more execution output but with less judgment to back it up. If what you already had was primarily judgment (the 10%), amplified, your judgment flows through AI execution into thousands upon thousands of correct realizations.

This is why the older you get, the higher your replaceability becomes—it's not age that makes you replaceable; it's that you spent a decade accumulating the 90% that is depreciating, while never deliberately refining that 10%.

The Stuff in Your Brain Has a Speed
At this point, I want to introduce an analogy from neuroscience that perfectly explains what exactly age should be accumulating.

Synaptic Pruning.

During human brain development, there is a "pruning" phase—the brain actively severs infrequently used neural connections, making the high-frequency pathways faster, thicker, and more myelinated. This process isn't "forgetting"; it's purification. After pruning, the brain's signal transmission speed jumps from milliseconds to microseconds.

You might wonder what this has to do with programming. It has everything to do with it.

In neuroscience, there's a concept called "myelination"—the outer layer of high-frequency nerve fibers gets wrapped in a fatty sheath (myelin), which can increase signal transmission speed by up to 100 times. This is why someone who has played the piano for a decade has a finger reaction speed ten times that of a beginner—it's not that their finger muscles are stronger; it's that the neural pathways have been myelinated.

The exact same mechanism applies fully to programming. Knowledge inside your brain has an access speed of O(1). Thinking of a design pattern, a system constraint, a historical lesson—it's on the order of seconds. You don't need to look up documentation or ask AI, because it has already been myelinated.

Knowledge outside your brain—Notion notes, saved documents, bookmarked links—has an access speed of O(n). You first have to remember where you put it, then search, then read, then comprehend. Each time takes at least n minutes.

A hundred internalized documents far outweigh a thousand bookmarked ones. This isn't rhetoric; it's math.

But here's the problem: the "decade of experience" for most programmers consists of knowledge accumulated outside the brain—API docs, framework configurations, records of pitfalls. In the AI era, the access speed for these things has converged. Whether you search your Notion or ask AI, it's O(n). Your "experience advantage" has been erased by technological equalization.

In his 1986 essay "No Silver Bullet," Brooks distinguished between two types of complexity: essential complexity (arising from the business domain itself, ineliminable) and accidental complexity (arising from tools and processes, eliminable by technology). Every generation of technological revolution over the past 50 years—from OOP to Agile, from microservices to low-code, and now to AI—has been eliminating accidental complexity. But essential complexity hasn't moved an inch.

The connection to synaptic pruning is this: Of your ten years of experience, how much is fluency accumulated in eliminating accidental complexity? That fluency is being zeroed out by AI. And how much is judgment accumulated in grappling with essential complexity? Those are the true myelinated pathways.

What genuinely appreciates with age are those myelinated judgment pathways in your brain: glancing at a piece of code and instinctively knowing "this should be split / shouldn't be split / was split wrong"; hearing a requirement and intuitively sensing "there's an invariant not defined here / there's a boundary condition unaccounted for / this solution is treating accidental complexity as essential complexity."

These judgment pathways cannot be fast-tracked. The ICSE 2021 fMRI study (Peitek et al.) found that semantic-level understanding and syntactic-level parsing activate entirely different brain regions. You can quickly read the syntax of code (AI can too), but can you construct the runtime semantic model in your head—state transitions, boundary conditions, concurrent interactions? That requires real programming time to build the neural pathways. AI can read code and output a summary in one second, but it has no "semantic understanding"—it has never run that code in its head, felt the tension of each branch, or anticipated the race condition in each concurrent interaction. You have, if you've truly coded for a decade and deliberately refined it.

The real value of age is not that "you know more," but that "you think faster." You've spent a decade pruning, leaving behind myelinated judgment pathways. That is the 10% AI cannot take from you.

So, What Exactly Are You Accumulating?
Back to the original question: why, as you age, does your replaceability actually increase?

Because most people's "experience accumulation" is essentially knowledge stacking—learning new frameworks, memorizing new APIs, stepping into new pitfalls, writing new notes. This is additive accumulation, and it has been equalized in the AI era.

What truly appreciates with age is multiplicative accumulation. You've seen enough failures to have refined enough heuristics, and your judgment pathways have been pruned to a fast enough speed. These are the multipliers for AI, and your true moat.

Kent Beck's ultimate formula says it most clearly:

Value = Brain Quality × Signal Density × Agent Amplification × Access Speed

Brain Quality: the depth of your judgment (alignment + decomposition + judgment)

Signal Density: the signal-to-noise ratio in your input (the ability to filter noise and focus on essence)

Agent Amplification: the multiplying factor of AI (converging for everyone)

Access Speed: the density of O(1) pathways for the knowledge inside your brain

When Agent Amplification converges, what truly separates the top from the rest are Brain Quality and Access Speed—and both require deliberate pruning, not natural stacking.

To judge whether a person is accumulating the 90% or the 10%, you only need to ask one question:

"Of everything you learned in the past year, how much of it has made you think faster when making your next decision?"

If the answer is "I learned a lot of new tech, but my decisions are just as slow"—you're accumulating the 90%.

If the answer is "I didn't learn many things, but my key decisions are noticeably sharper"—you're accumulating the 10%.

Age does not make you replaceable. What is replaceable is the 90% of execution skills you spent a decade accumulating. The 10% of judgment that truly appreciates over time—are you genuinely accumulating it, or are you using the phrase "I'm experienced" to cover up the fact that you've never once refined your heuristics?