Note to self, written after a long walk, when the thinking is quieter.

Twenty-six years of typing code teaches your hands things your head never agreed to. Now there’s a collaborator who types faster than I do, never gets bored, and is nearly always plausible. Plausible is the dangerous word. I want to remember how I work with it, so I don’t drift into something I never chose.

What I hand over

I hand over the work where the shape is already decided and only the labor remains. Wiring a component to a data source I’ve already described. Writing the tedious variants of a thing I’ve already designed once. Scaffolding tests for behavior I can state in a sentence. Translating a pattern from one place in the codebase to another.

The test is simple: could I explain the finished result before it exists? If yes, I can delegate it. The decision is made, and what’s left is transcription.

What I keep

I keep the pen for anything where the thinking is the work. The first sketch of an API. The naming. The decision about what a component refuses to do. The spacing scale, the rhythm of a layout, the way a transition should feel under a thumb on the iPad.

These aren’t hard problems to type. They’re hard problems to decide, and deciding is where taste lives. If I let the machine decide, I get the average of everything it has seen. Competent, smooth, and nobody’s.

So I start the important things by hand, badly, in plain language or rough code. Then I let the AI help me push on it. The order matters. If I start from its draft, I end up editing its idea. If I start from mine, I end up sharpening my own.

The strange intimacy of reviewing code I didn’t type

Reading code I didn’t write is an old skill. But this is different from reviewing a colleague’s pull request. There’s no history behind it, no tired Thursday-night shortcut I can sense in the commit. It arrives clean and confident, and the confidence is the thing to distrust.

It feels a little like hearing a cover of a song I know well. Every note is right and something is missing, or something has been quietly changed. I only catch it because I know the original in my body.

So I read slowly. I’ve stopped skimming for “does it run” and started reading for “does it sound like us.”

Here is what I ask of every piece of generated code:

• Would I have written this? If not, is it better, or just different?
• Does it use our tokens and patterns, or has it invented a parallel universe?
• What did it add that I never asked for?
• What edge did it quietly smooth over?
• Could I defend every line to Future Me, six months from now, with no context?

That last question does the most work. If I can’t defend a line, it doesn’t ship, however well it behaves.

The quiet failure mode

The risk isn’t bad code. Bad code announces itself. The risk is acceptable code, accepted over and over, until the product has a texture I never chose. Each small approval feels like nothing. Together they are a style, and it isn’t mine.

Design systems taught me this long before AI did. A system doesn’t decay from one big wrong decision. It decays from a hundred reasonable exceptions. Reviewing generated code is the same discipline: hold the line on small things, because small things are the whole surface.

Speed is not the point

It would be easy to treat all of this as a race. I don’t want to. Depth over efficiency is how I’ve always wanted to build, and a faster typist doesn’t change that. If anything, it raises the stakes, because now I can make a mess at a pace I never could before.

What I actually want from the collaboration is room. Room to stay with a hard decision a little longer because the mechanical parts are handled. Room to polish the last ten percent, the part people feel without noticing. Room for the walk, and for the idea that only turns up when I’m away from the screen.

A practice, not a rule

I don’t think this settles into rules. It’s closer to how you listen to a record: the same album sounds different depending on what you’re carrying that day. Some days I hand over more. Some days I write every line myself because the writing is how I figure out what I think.

What stays constant is the question underneath. Whose work is this? When I close the laptop and carry the day back to the Loom, I want the answer to be: mine. Not because I typed it, but because I chose it, line by line, and can say why.

Stay the author. Let the machine hold the pen when the pen doesn’t matter, and take it back the moment it does.