Saturday afternoon. Artichokey open in one pane, an ADR (Architecture Decision Record) in the other. An agent is writing the next hunk. I'm not. I'm reading the decision we wrote down yesterday, asking whether it still holds before I glance at the PR (pull request).
I enjoy reading code. I enjoy writing it. And I'm letting go of the wheel anyway — the wheel happens to be coding.
Not quitting. Freeing context for the problems that actually need me, and letting something else take the tasks that chip away at brain power one commit at a time.
A daily tool, mostly hands-off
Artichokey is different. It's a tool I'll use every day, built in a language I played with for years and never shipped anything real in. I've never had more fun.
I used to read every PR line by line. I still do when the stakes are high — a path I don't trust yet, a rename that will confuse the next reader. With Artichokey the loop is looser. Agents draft. I steer the shape. I merge when what landed matches what I meant. The fun didn't leave. It moved — from the keystrokes to staying oriented while the typing happens elsewhere.
Rust was on the to-learn list next to Go. If it compiles it should run, and the errors are sharp enough that an agent can eat them as feedback without me translating. That's why it fits this loop. Not the whole point of the piece.
ADRs as the thing that lets you let go
The core got ADRs. I draft the rough shape with an LLM (large language model) — the decision, the alternatives I can name, the thing I'm afraid of getting wrong. Agents research and flesh them out. I read the result the way I used to read a PR: does this still sound like me? Then they implement. Review agents suggest changes; I agree or don't; a worker picks up what I greenlit. I glance and merge.
That glance is the hard part. The itch to dive in and rewrite the hunk myself never fully goes. Sometimes I take the wheel back for a one-liner I already know. Often a clearer note on the ADR and another pass is faster than owning the whole branch again — same rule as mornings when the overnight ask went soft: small nits while the context is loaded; another pass when it got the shape wrong.
Design docs finally clicked
I'd hated them for years. Agreement, I thought, belonged in PRs — fight it out in the diff until everyone is tired. That becomes a firehose. You drown in hunks and lose the shape of the system.
What clicked: stakeholders need the high-level, not the implementation. A short ADR is easier to argue with than a thousand-line review. You see the system evolving in a handful of decisions instead of a scroll of green and red. Building with my hands mostly off the keyboard is when that stopped being theory and started being how I stay sane.
I used to think docs were for other people. Turns out they're for me — the version of me who will open this repo next week and need to know why we bent the design this way.
Course-correct, don't steer every line
Will I understand every line eventually? Probably. On a roll I let it go. The ADRs steer. Check-ins course-correct. The quieter corners — plugins, the edges — get less eyes-on for now. Three days into the adventure, that still feels slightly reckless. Slightly right.
I can't run this loop at work. The pace won't allow it — too many stakeholders, too little room to wait on a doc. A personal project will.
Letting go isn't indifference. It's choosing where the attention goes.
I still love coding. I'm just spending that love on the shape of the thing, not every keystroke that builds it.