Write DNA, Not Code

The Distinction

DNA doesn't say "when you encounter pathogen X, produce antibody Y."

DNA says "here's how to build a system that figures out antibodies on its own."

It doesn't encode behavior. It encodes the machinery for generating behavior.

The immune system isn't written in the genome. The blueprint for building an immune system is in the genome. The actual immune system is constructed at runtime, shaped by whatever environment the organism encounters. Two humans share the same immune system spec. Their actual immune systems are completely different — because they were built by different lives.

Same with the brain. DNA doesn't contain thoughts, skills, or knowledge. It contains the spec for building a neural architecture that acquires thoughts, skills, and knowledge through experience. 750 megabytes doesn't encode everything a human can do. It encodes how to build a machine that can learn to do everything a human can do.

Two Kinds of Information

Code tells a system what to do. Precise, deterministic, exhaustive. It handles every scenario the programmer anticipated. Adding capability means adding more code.

A spec tells a system what to become. It describes the machinery for generating behavior, not the behavior itself. Capability emerges from the machinery interacting with its environment. Adding capability means improving the spec, not enumerating more cases.

| Property | Code | Spec (DNA) | |----------|------|------------| | Says | "Do X when Y" | "Build a system that figures it out" | | Handles | Known scenarios | Unknown scenarios | | Scales by | More rules | Better machinery | | Size grows with | Number of cases | Quality of the blueprint | | Tested against | Test suite | Reality |

The AI Development Debate

The current conversation about AI-assisted development is almost entirely about using AI to write code. Generate functions. Complete implementations. Produce test suites. All of this is useful. And all of it is building in the wrong direction.

Code — no matter how much of it AI generates — is deterministic instruction. It handles what the programmer (or the AI) anticipated. Every unhandled case is a bug. Every novel scenario is a failure mode. Scale the code, and you scale the maintenance burden linearly.

The alternative: use AI to write specs.

A spec is a generative document. It describes what a system should be capable of becoming. It defines acceptance criteria, constraints, and selection pressure. Then an agent — human or AI — builds from the spec, iterates, and what emerges isn't what anyone explicitly wrote. It's what survived the process.

What Specs Look Like in Practice

A PRD (Product Requirements Document) is closer to DNA than to code. It says "here's the problem, here's what the solution looks like, here's the constraints." An engineer reads the PRD and builds a system. The system isn't a translation of the PRD into code. It's an interpretation — shaped by the engineer's environment, tools, and judgment.

Take it further. A well-written slash command — like /mindreader — is pure spec:

Read everything Reeves knows about this person. Synthesize a picture of what they actually need. Surface what they're avoiding. If --act is set, create tasks and draft messages.

That's not code. It's DNA. It describes the machinery for generating intelligence about a person's life. The actual intelligence is assembled at runtime, shaped by whatever data exists at the moment. Run it today, get one result. Run it next month with more data, get a richer result. Same spec. Different organism.

The Ralph Loop as Embryogenesis

DNA doesn't execute once to produce a human. It drives a continuous developmental process — cell division, differentiation, organ formation, growth — where each stage builds on what the previous stages created. The same genome, expressed differently in different contexts, at different times.

The Ralph Loop works identically. The same prompt (the spec) is fed to an agent repeatedly. Each iteration, the agent sees its own previous work — the current state of the codebase, the files it created, the tests that pass or fail. It doesn't get new instructions. It gets the same instructions in a new environment (the one it created last time). Each cycle, the system builds on what it built before.

The spec stays constant. The organism develops.

This is embryogenesis, not compilation. The code isn't written from a blueprint. It grows from a blueprint through iterative interaction with an environment. And like biological development, the result is often more sophisticated than anyone could have designed deterministically — because it was shaped by selection pressure (tests, reviews, real outcomes), not just by intention.

The Shift

Stop asking: "How do I use AI to write more code?" Start asking: "How do I use AI to write better specs?"

Stop building: Larger, more detailed codebases that handle more explicit cases. Start building: Smaller, denser blueprints that generate systems capable of handling cases nobody anticipated.

Stop scaling: The organism. Start improving: The DNA.

The 750 MB argument isn't just about biological efficiency. It's a design principle. The most powerful systems aren't the ones with the most instructions. They're the ones with the best blueprints — generative specs that build adaptive machinery through lived experience.

Write DNA, not code. Let the systems build themselves.