Feral Code

Suppose you wanted to increase a programmer's velocity. You mathematically have two choices: make them type faster, or shrink the size of the program. Conventional wisdom fixates on the first because keystrokes are easily measured. We persistently treat programming as the physical act of producing text, completely ignoring the biological reality of what a developer actually does. As Peter Naur mapped out decades ago, programming is actually "theory building". It is the invisible, cognitive labor of loading a system's state into your head. The actual text resting in the IDE is just exhaust.

The implication is that code functions strictly as a liability rather than an asset.

If we model programming as mental state management, hacker velocity reduces to a simple equation: the capacity of your mental model divided by the total lines of code. The numerator is strictly bounded by human biology. You can only hold a certain number of variables, conditionals, and state transitions in your working memory at any given moment. This means the denominator entirely dictates your speed. Every time a function is written, the denominator grows, mathematically dragging your velocity downward. This is the brutal physics underlying the industry heuristic that the ratio of time spent reading versus writing is well over 10 to 1. You are constantly forced to re-read the denominator just to temporarily refresh the numerator.

Why does this happen? The mental graph naturally decays. A programmer spends most of their day rebuilding the map of how variables and logic interact before they can safely alter a single character. Every time you add a line of code, you increase the surface area of the system that must be loaded into RAM tomorrow.

Smart hackers currently celebrate large language models as a massive boost to productivity and a magical unblocker. They correctly observe that it removes the short-term friction of syntax lookups and boilerplate. By treating typing as the primary bottleneck, they happily let neural networks spray thousands of lines of logic into their repositories. They view this infinite generation as a pure advantage. It isn't.

Generating massive blocks of logic without typing them shatters the historical taxonomy of software. Before the current era, code was almost exclusively "Owned." Because a human had to manually synthesize and type every function, the structure was simultaneously built in the codebase and mapped in the mental graph. When a bug surfaced in Owned code, your brain could navigate straight to the source. You already knew which module was failing because you mapped the geography yourself.

When you let an LLM write a feature, you introduce a dangerous new species into the ecosystem: Feral Code.

Feral Code exists on a hard drive, but it entirely skips the critical theory-building phase in your brain. It is wild, untamed, and unmapped. You do not own it. Because it bypassed the cognitive friction of being manually typed, it lacks the neural tether that allows a developer to instantly recall its purpose or architecture.

Tracing the downstream math of this environment reveals an inevitable structural collapse. By aggressively committing Feral Code, you artificially drive the denominator of the velocity equation toward infinity while your numerator remains utterly static. The velocity ratio mathematically approaches zero. A developer might feel remarkably fast during the first afternoon of an AI-assisted project as they generate UI components, wire up database schemas, and watch the system magically compile. Then they freeze.

The developer inevitably encounters a cryptic edge case deep inside a feral routing function. They suddenly realize they have absolutely zero mental model of the state machine they are attempting to debug. Because they skipped the initial cognitive labor of theory building, they cannot intuitively traverse their mental graph to isolate the flaw. They have to stop and read the Feral Code line by line, attempting to painstakingly reverse-engineer a massive alien architecture just to safely change a boolean flag — a process that incurs catastrophic cognitive debt.

The danger of Feral Code is that it behaves exactly like an invasive species. When you commit unmapped logic into a shared repository, you force every other developer on your team to interface with an API that nobody in the building actually understands. The team begins treating the feral module with an almost superstitious dread. They build brittle wrappers around it to avoid touching the core logic. The resulting architectural friction slows the entire engineering org to a crawl.

Geoffrey Litt recently diagnosed this exact phenomenon, noting that "understanding is the new bottleneck". The consensus resonating across Hacker News confirms that the community is already empirically hitting this wall. Hackers are discovering that when you automate the typing without automating the comprehension, you are essentially just maximizing your own cognitive debt. You get the code, but you lose the map.

And this structural trap is an immutable law of physics rather than a temporary artifact of the current hype cycle waiting to be solved in GPT-5. Software velocity is bound by human biology, and human working memory does not scale exponentially. A startup with a codebase that exceeds the founder's mental graph is a dead walking company. You simply cannot debug a black box you never bothered to map in the first place — the math simply will not allow it.

So here is the only rule that matters for maintaining hacker velocity in an age of infinite generation: if you don't understand the output, delete it.