Why I Still Build by Hand

The question I keep getting

Some variation of it, every couple of weeks. "Why do you still write so much code yourself? You have the tools. Just ship the prompts."

It is a fair question. I do use the tools. A lot of this very site was built with an AI agent in the loop. But the answer to "why not hand the whole thing off" is not nostalgia, and it is not craft romanticism. There are a handful of things that only happen when you are the one still sitting at the keyboard, and none of them are replaceable.

What I mean by "by hand"

To be clear, "by hand" does not mean no AI. That ship has sailed, and I would not want it back.

What I mean is that I am still the one reading the code. I am still the one running it the first time. I am still the one using the thing I built. The AI writes, suggests, corrects, explains. I decide, accept, reject, ship. The loop goes through me.

If that loop skips me entirely, something important stops happening.

Reading your own code is how taste forms

Taste is not a vibe. It is a set of instincts about what looks right, and those instincts only form when you read a lot of code and have reactions to it.

When I read code I wrote, or accepted, yesterday, I notice the shortcuts I took when I was tired. I see which abstractions I reached for too quickly and which ones I avoided too long. I catch the moment where I stopped thinking and just wanted the thing done.

That reading is the feedback loop that makes me better. Skip the reading and the loop never closes. You ship more, sure. You learn less.

Friction is signal

An AI assistant is extremely good at smoothing away friction. That is most of the pitch. You say what you want, it writes it, the annoying part goes away.

The problem is that annoying parts are usually pointing at something. When a function is hard to write, that is often because the model in your head is wrong. When a component needs six props to do anything useful, that is a design smell. When you keep copy-pasting the same five lines, an abstraction is asking to exist.

If you never feel the friction, you never read the signal. The code gets written. The lesson does not get learned.

You cannot delegate the context you do not have yet

Twenty minutes into a build, you know things about the problem that you did not know when you started. Edge cases you would not have predicted. Shapes in the data you did not see from outside. Decisions you made that closed off three other decisions.

You could not have briefed an agent on any of it at the start, because the context did not exist yet. It formed while you were building. That is what building is for.

This is the reason that the best AI-heavy workflows I have seen still have a human in the middle, steering. The context that steers is earned one build at a time, and there is no shortcut to earning it.

Side projects are a gym

There are fifteen apps on this site. Most of them are not commercially useful. None of them were strictly necessary. They exist because I wanted to build them, and because the act of building teaches me things that show up everywhere else.

Vote Room taught me a lot about async primitives and what "good enough" real-time looks like. The CV chat taught me how to scope a small RAG pipeline without drowning in infra. The workflow editor forced me to think hard about canvas interactions I had previously hand-waved past.

None of those lessons were the point when I started. They arrived as a side effect of shipping. That is the compounding part.

The part nobody talks about

Shipping something you made, and then using it yourself, is one of the better feelings in this line of work. Not ego. Closure. The loop closes. You had an idea. You held it in your head. You turned it into a thing. You used the thing.

That feeling is underrated and undersold. It is the reason most of us got into this in the first place, and AI being in the loop does not take it away. If anything, it makes the loop shorter, so you get to feel it more often.

I am not going to stop doing that because a pitch deck tells me to.

The point

Use AI. Use it aggressively. It is the most productive I have ever been.

But stay in the loop. Read the code. Run the code. Use the thing. The parts of this job that actually make you better are on the other side of that loop, and no amount of clever prompting gets you around it.

Build by hand because that is where the useful parts of the work live. The AI is a gift. The loop is still yours.