I don't type code anymore
So here's a confession that would have embarrassed me a year ago: I write software every day, and I almost never type the code anymore. AI agents write most of it under my direction. And the reason I'm finally saying that out loud is all the posts I keep seeing that get this exactly backwards.
If you go by LinkedIn or Reddit, you'd think you can type a few paragraphs into a chat box and get a bug free app that works the first time, every time. Those people live in a fantasy. I say that with love, because the tools really are something. I'd honestly call them near Harry Potter level stuff. But I use them all day, every day, and getting from "the demo ran" to "I'd bet production on this" is still hard. It's just a different kind of hard than it used to be.
The typing was never the engineering. What's left when you stop typing is the part that was always the actual job: the architecture, the constraints, the failure modes, and the verification. The ideas. The structure. The logic. An agent can write you a function in four seconds. Deciding whether that function belongs in your system, what happens when it fails at 2 AM, and whether it actually does what it claims, that part didn't go anywhere. If anything it got bigger, because the code shows up faster than you can read it.
And here's the thing nobody warns you about. The failures are quiet and confident. Nothing crashes. An agent will reference a function that doesn't exist in your codebase, and the code around it looks completely reasonable. On a warehouse mapping project of mine, a vision model read the branding off cardboard boxes and reported it as rack labels, with high confidence. The wrongness shows up looking right. Which means the real job isn't prompting. It's verification.
I didn't trust myself to do that verification by eyeball, so I built tools for it.
bosun coordinates parallel AI coding sessions so they can't step on each other. One session works the database, one works the backend, one works the front end that users see, each in its own isolated copy of the repo, and only one command is ever allowed to touch the main branch. It's been through two security audits with zero high severity findings open.
Leonard is the distrust layer. Before an edit lands, a hook rejects any reference to a symbol that doesn't exist. After an edit, a verifier runs and writes the outcome to a claim ledger, so "it works" is a recorded fact and not a feeling. It's at 46 releases and four security reviews, mostly because I keep finding new ways for confident nonsense to sneak past me.
Now the part that keeps me humble. Those gates were built to catch the AI, and lately they keep catching me. In the last couple weeks my own review process caught three of my mistakes. A document of mine claimed two merged pull requests on a project where one was merged and the second was still open. A number drifted from 41,284 to 34,000 between a writeup and its title. And I caught myself about to say I "found" a bug that I had only fixed, when someone else had actually reported it. Small stuff, the kind of drift that happens to everybody. But that's the point. Verification isn't for the AI. It's for everyone in the loop, and I'm in the loop.
I should say plainly what this doesn't mean. Not typing code doesn't mean not reading code. I read and judge everything that ships, and I'm still grinding through Go fundamentals by hand, the way pilots still practice hand flying even though the autopilot does most of the cruising. The deeper I understand the language, the better a reviewer I am, and the reviewer is the whole ballgame now.
So that's how I work. I do the engineering. The architecture, the constraints, the failure modes, the verification. Agents do the typing, and my own tooling keeps all of us honest, me included. The magic is real. It just doesn't remove the engineering. Or at least that's been my experience, one project at a time.