Twenty Years, Zero Posts

Claude drafted this from my notes and session logs. I edited it. The numbers come from my logs, my repos and this blog, and a different agent checked them before it went up.

Why I never wrote

I've spent twenty years building software in regulated industries, most of it at a health insurer. In all that time I didn't publish a single blog post.

It wasn't for lack of ideas. Big regulated companies are built to say no to new things, mostly for good reasons, and I watched a lot of good ideas die on the way through. After enough of that, it follows you home. You stop starting things.

So I quit fighting it and put my energy into the rest of my life. I married my best friend. I've spent more time with my kids than almost any dad I know. We've been to more beautiful places in the last ten years than most people get to in a lifetime. We've had some hard times too.

What I didn't have was the drive to stay locked on hard problems that weren't going anywhere. I don't regret that trade.

What changed in April

Coding agents got good enough that one person could take an idea all the way to a working thing. I didn't need a committee or a slot on somebody's roadmap.

That was the part I'd been missing. I had plenty of drive for problems I could actually finish. Since late April I've opened 98 repositories. In them: a test bed for a gateway that redacts health data before it goes to an AI vendor, a system that answers questions about a clinic's data and refuses instead of guessing, a dashboard that reads my own agent logs, a navigation app, a window manager, and a lot more. About fifteen are live or installable. The rest are prototypes, research, and tools I built for myself.

Out of curiosity I had a model estimate how long all of it would have taken experienced engineers without AI tools. It went repo by repo, threw out anything copied, generated or just data, and costed the design, tests, docs and research along with the code. It came out to about 94 person-years, with a range of 59 to 145. Simple lines-per-day rules of thumb give anywhere from 70 to more than 200.

I don't take that number literally. Even if it's off by a lot, it says how big the change was for me.

Why I let an AI draft it

Building was half of it. Writing about it was the other half, and that's where I'd always stopped. This blog has 49 posts about work I did between April 28 and October 14. Without two things, none of them would exist.

The first is logs. I keep every Claude Code session from my main machine, back to April. When I write about something, I'm not working from memory. The failing test, the wrong number, and the exact thing I typed when the work got stuck are all there with timestamps, next to my notes and the repos themselves.

The second is drafting. I give Claude the logs and my notes, it writes a first draft, and I fix what's wrong and cut what doesn't sound like me. Then a different agent, one that didn't write the draft, tries to knock down the claims.

I didn't always do that last step. The 38 posts I published in a single day on September 12 (posts here are mostly dated by when the work happened, not when they went up) went through rewriters and no checker, and I was fixing an invented line in one of them that same night. This post got a checker. It refuted four of my claims and flagged eight more as stretched, and I fixed all twelve before it went up.

I know plenty of people stop reading the second they hear a post was AI-drafted. The usual complaint is that it cost the writer nothing, costs the reader real time, and nobody checked it. The typing did cost me very little. The work behind most posts took days or weeks of logged sessions, and the thinking is real work, whether it happens upstream or downstream. Here's what it looks like.

I wrote a post comparing two coding-agent tools, including what one tool's usage meter missed. The first draft had 24 findings. I handed every one to an independent reviewer told to refute them. None held up as written. Nine were refuted and fifteen came back overstated, and the reviewer ran out of budget before testing five of the eight areas. What I published was the handful of things you can read straight off a single log line, a section on what died, and a note on what never got tested.

In another, about a Go server that stopped scaling at two cores, my first write-up said it was CPU-bound. A mutex profile showed it was waiting on a lock around the logger. The wrong sentence is still in the original document, with a dated correction above it.

The other objection is that writing is the thinking. I buy that when the writing comes before the building, like a design doc or an essay working out an idea. Mine comes after. The thinking happened in the sessions, while things broke, and the logs have it with timestamps.

I didn't type most of the sentences in my posts. I did the work, I made the calls when it got stuck, and I made the corrections. You can check all of that.

Why it comes out in bursts

Look at the dates on my posts and you'll see clumps: nineteen between August 8 and 30, five in four days in September, almost nothing in June. Those are when the work happened. The publish dates are lumpier still. Two posts went up in May, and the other 47 between September 10 and October 14, 38 of them in one day.

From the outside that reads like a content farm. It's how I work. I go hard at something for a stretch, the sessions pile up, and then I go quiet. The write-ups come later, all at once, from the logs.

The walls are still there

I'd like to say it all worked out. It hasn't yet.

Inside a big company, a working prototype doesn't move a decision much faster than a slide did. Outside, I've sent applications for months and mostly heard nothing back. Most of a career at one employer reads a certain way to a resume screen, no matter what's on the page.

What's different is that the work exists now. It's running, with tests and numbers, and anyone can poke at it. Getting anyone to look is the hard part.

That's part of why I'm posting this. I'm looking for a principal or staff IC role, remote. If that's you, my email's at the bottom.

If you're sitting on ideas too

I don't think I'm unusual. I'd bet a lot of people reading this have years of hard-won knowledge in their heads and nothing written down to show for it. Writing takes forever, and getting help from an AI gets treated like cheating.

What worked for me is simple. Keep your logs, all of them. Let a model draft from them. Have something other than the writer check every claim. Say up front how it was made.

If you want to dig through your own Claude Code sessions, I built claude-code-log to read mine.

Whatever you build next, keep the receipts. Someday you'll want to write it up.

-- Justin Higgins. Software Engineer, Midwest. Twenty years of no posts, then 49 drafted from the logs, with the corrections left in.


Companion pieces: Git Could Not Tell Me Who Wrote It - the weekend an agent wrote all the Swift and the transcripts showed what I did. The Writer Can't Be the Checker - sixteen write-ups, sixteen corrections from checkers that never wrote them.

Reactions, disagreements, war stories: jchigg2000.dev@gmail.com