AI-assisted coding bell-curve meme

Code was a medium. Not the product. Not the craft. The medium.

The machine does not admire your naming conventions. It does not appreciate the abstraction layer. It executes. And yet, somewhere along the way, we convinced ourselves that the writing of code was the point, rather than a means to one.

Jensen Huang said it plainly: “The purpose of a software engineer is to solve known problems and find new ones. Coding is one of the tasks.”

Some engineers bristled. They heard the wrong thing. He was not diminishing code. He was correctly categorizing it.

The tax you paid to ship

The gap between what I want done and code that does it was always the job. The outcome was the job. Code was the tax you paid to get there.

Agentic tools have not automated programming. They have made the tax cheaper. You describe the outcome; the agent drafts the filing. You review it.

That is a more honest relationship with the medium. And honesty, it turns out, is uncomfortable for an industry that built its professional identity around paying that tax with elegance.

Clean code was written for humans

Every quality metric we use, readability, DRY principles, abstraction clarity, was designed for one human to hand code to another.

But agents are now both writing and reading code. And an agent does not need your comments. It does not benefit from your nested abstractions. It works better with less surface area to misread.

The conventions we treat as gospel were built for a consumer that is no longer the only one in the room.

This does not mean clean code is dead. It means the definition is overdue for an update. A codebase optimized for agent-assisted workflows might look leaner, flatter, and more annotated in markdown than in inline comments. Documentation moves out of the code and into context files that actively shape how the agent writes and extends the repo.

That is a different kind of craft. Not a lesser one.

The repository is becoming a hybrid artifact

The codebases of the next five years will carry as much prose as logic. Not documentation trailing six months behind the code, but living context that instructs the agents maintaining it.

CLAUDE.md. AGENTS.md. Architecture decision records written not for your future colleague, but for the model that will touch the code before they do.

The source code is for the machine. The markdown is for the agent. The agent does the translation.

Which raises a question worth sitting with: if the most valuable part of a modern repository is its surrounding context, what does that mean for how we evaluate engineering work? We have metrics for code coverage, complexity, and performance. We have almost nothing for the quality of the prose that now shapes how that code gets built.

We built the vault before we knew what we were preserving

In 2020, GitHub ran the Arctic Code Vault campaign, buried a snapshot of public repositories in a coal mine in Svalbard, Norway. A time capsule meant to last a thousand years. At the time it felt like a stunt.

It looks different now. A codebase stripped of its context files is code without an operating manual. The logic is there. The intent is not.

Future developers, human or otherwise, will not just need the source. They will need the surrounding layer of decisions, constraints, and instructions that gave it shape.

Code was always a means to an end. The agent era did not change that. It just made it impossible to pretend otherwise.

The question now is not whether your code is clean. It is whether your thinking is.