← ALL POSTS

Code Is No Longer the Product

When writing software gets cheap, the value moves to everything around it.

WESSCOBY · NOV 2026 · 4 MIN READ

I don't think code was ever the product. It just used to be the most expensive part of making one, and when one part of a thing takes most of the effort, it's easy to start treating that part as the thing itself.

That's how a lot of us learned to think about it. Lines shipped, tickets closed, pull requests merged. The code was what you could point at by the end of the week, so the code was what got counted.

That cost has dropped. Not to zero (someone still pays for the tokens, and someone still has to read the output), but far enough that it's no longer the part that decides whether something gets built. A lot of the code I've shipped this year was written by an agent. My job on those projects was mostly everything else, and everything else turned out to be most of the job.

So here's my two cents on where the value went.

Deciding what should exist

An agent will build whatever you describe. It won't stop and tell you that you described the wrong thing. It'll build the wrong thing quickly and cleanly, with tests.

That makes the decision before the code more expensive to get wrong, not less. When building took a month, a bad idea had a month of friction to die in. People asked questions in standups. Someone eventually said "wait, why are we doing this?" Now a bad idea can be finished before anyone has had time to doubt it.

So the most valuable thing I do on a project is usually the least visible: working out what it's for, who it's for, and what it should refuse to do.

Writing it down

I used to treat a spec as something you write so people stop asking you questions. Now it's the thing I maintain most carefully, because it's what the code gets regenerated from.

What surprised me is how specific it has to be. "Handle errors properly" means nothing to a model. "A failed read shows the reason, never a zero" means something. The notes that matter aren't descriptions of the system. They're rules, in plain English, about what must never happen, and most of mine started as a mistake that happened once.

Writing clearly has quietly become a technical skill. I'd go further: it's the one I'd hire for first.

Knowing it works

Generating code is easy. Knowing it's correct isn't, and that gap is where most of the real engineering lives now.

Generated code is very good at looking right. It compiles, it reads well, it follows the conventions of the file it lands in. The bugs it does have are rarely the loud kind. They're the quiet kind: a migration that only works on an empty database, a cache that keeps serving yesterday's data, a date range that's off by one day in one timezone.

Tests catch some of that. Types catch some. Using the thing for real, the way a person would, catches a surprising amount that both of them miss. None of that is new. What's new is that these used to be how you checked your own work, and now they're how you check work you didn't write and might not have read closely.

If I had to name the biggest change in how I work, it's this: I spend less time writing code and more time building ways to find out whether it's wrong.

Owning it after it ships

Code doesn't stop at the merge. Somebody has to run it, update it, keep it secure and answer for it when it breaks at 2 a.m. That somebody is still a person, and the agent that wrote it won't be in the room.

I think this is the part that gets underrated. Cheap code means more code, and every line is something somebody has to maintain. It's never been easier to build a system nobody fully understands, including the person who shipped it.

Being someone people trust

Users don't buy code. They buy something that solves their problem, from someone they believe will still be around to fix it next year. When anyone can build the same features over a weekend, the features stop being the difference. Showing up, answering, and keeping things working is what's left, and none of that can be generated.

What I'm doing about it

Less of the job is typing now, and I've stopped pretending otherwise. In practice that means a few things.

  • I write down what I want before I ask for it, and I keep that writing as up to date as the code.
  • I read generated code the way I'd read a pull request from a confident stranger. I assume it compiles. I don't assume it's right.
  • I put real effort into checks, because they're what let me move fast without lying to myself.
  • I try to stay close to whoever is going to use the thing. The further I drift from the problem, the more my output looks like anyone else's.

The catch

None of this means code doesn't matter. If anything it matters more per line, because there's so much more of it and less of it has been read by the person who shipped it. Bad code is still expensive. Writing it just got cheap.

The question used to be "can we build this?" Now it's "should this exist, and how will we know it works?" I think the people who get good at the second question will be fine. The ones who only know how to answer the first are going to find it answered for them.

The code was always the means. For a long time it was the hardest means, so it was easy to mistake it for the end. That excuse is gone.