I stopped writing code in 2015. I just shipped a platform.
The ladder deal says you trade the keyboard for the org chart and never get the keys back. Agents rewrote that clause. Typing got cheap. Judgment didn't, and a decade of management sharpens exactly the half that got expensive. The receipts are one link away.
The last production code I shipped was Scala, around 2015.
Over the last four months I built an internal platform. Solo. An engineering metrics system pulling Jira, GitHub, HiBob, and calendars into one view. An AI cost layer that attributes spend down to teams. A meeting transcriber with real encryption and identity. A showcase service, a skills marketplace, and the Terraform foundation underneath all of it.
Not toys. Things people use.
I didn't get younger or smarter. The bottleneck moved.
After 2015 I went up. More people, more countries, more org design, less keyboard. That's supposed to be the deal. You trade building for leading. You slowly lose the keys to the codebase.
I made that trade on purpose. I don't regret it. But I never liked the fine print: the price was going quiet as a builder.
The scarce thing changed
Typing got cheap. Judgment didn't.
For most of my career the scarce thing was typing. Knowing the syntax cold, holding the API in your head, remembering which corner of the build system bites when you touch it. That's the muscle you lose first when you stop coding daily. And it's exactly the muscle agents now rent to you for cents.
Picture the line that runs from idea to shipped. For twenty years the jam sat at the typing station, so we hired and promoted for typing. An agent now clears that station in seconds. The queue doesn't disappear. It piles up one station later, at judgment.
Judgment is the part nobody rents you.
What to build and what to refuse. Where the real risk sits. Which "done" is actually done: an agent's done means the tests pass, your done means the on-call can run it and the number it prints is defensible. Whether the clean figure on the dashboard is lying to you, which it usually is, because attribution is the entire game and nobody gets it clean.
Why does a 403 leak when a 404 doesn't?
Because a 403 on a guessed URL confirms the resource exists. You just told the prober the safe is real, only locked. A 404 denies there is a safe at all. An agent will cheerfully write either one, in perfect syntax, in half a second. Knowing which one to demand is judgment, and no model carries it for you.
The ladder story missed the turn. A decade of management sharpens exactly that half. Typing skill decays in months; judgment compounds for decades. Every roadmap fight, every incident review, every promo case was a judgment rep. You've been training the surviving half of the job in meetings the whole time.
I wrote years ago about when to trust your gut: a gut is compressed experience.
The leader who stopped coding turns out to be carrying the half of the job that got more valuable, and renting back the half that got cheap.
Argue from artifacts
I can now prototype the thing I'm about to ask a team to build. In an evening.
So I walk into the room with a running artifact instead of a slide. "Can we build this" dies in the first five minutes. The rest of the meeting is whether we should.
The move deserves a name: arguing from artifacts.
"Here's the thing, here's what it cost, here's where it broke" beats any amount of confident hand-waving. Including my own. A deck asks the room for one thing: trust me. A thing that runs doesn't ask.
I've killed several of my own ideas this way, faster and with less ego, because the artifact embarrassed them before a person had to.
Some of those kills are public: a three-model jury I fired for one reasoning model, a cover pipeline whose V1 lived four hours, twelve repos archived with verified bundles and tombstones.
An idea that dies in a demo costs an evening. The same idea dying on a roadmap costs a team a quarter.
The receipts
The 2026 version of "trust me" is a link.
The platform above isn't a list of nouns you have to take on faith. Most of it has a write-up, mechanism and failure data included:
| The claim | The receipt |
|---|---|
| AI spend attributed per team, without building a weapon | What our AI tools cost, per team |
| The cost layer is live enough to publish my own bill | My homepage shows my Claude bill |
| The transcriber's real product was privacy and identity | The transcription was the easy part |
| Every PR passes a cross-vendor review layer | Three AIs review my PRs |
| Even the GitHub org is code with a plan and a diff | My GitHub org is a 273-line Terraform plan |
| Losers get killed with a checklist, not hoarded | I archived 12 of my 45 repos in 21 days |
| The observability stack answers to a budget | 9 containers. 1 VM. No Datadog bill. |
| Rewrites get the honest math, not the victory lap | The rewrite cut over in 12 days |
If a claim in this post feels thin, the depth is one link away. That's what arguing from artifacts buys you: the argument stops living in the adjectives.
What this is not
It's not "managers should all go back to coding full time."
Your job is still the team. If you're heads-down in a worktree while your org drifts, you optimized the wrong thing.
And it's not "you don't need engineers anymore."
I built the parts I could specify. The engineers I work with build the parts that need someone living inside the problem for months, carrying context no spec captures. Those are different jobs. One didn't eat the other.
The rewritten clause
The trade I made in 2015 had a hidden clause, and it just got rewritten.
You can go up and keep the keys now.
Not to ship the production system yourself. That's still the team's. But to stay fluent, and to test your own ideas before you spend anyone else's time on them.
A leader who can still build, now that building is cheap, has an unfair advantage.
Use it on your own ideas first. They deserve the scrutiny most.