The Work That's Left

An AI agent built almost all of this website. Not the words (the words are mine), but nearly everything else: the components, the migration scripts, the fussy TypeScript I didn't feel like typing out by hand. I only get my hands dirty when a change is small enough that doing it myself is faster, or when the agent can't quite work out what's wrong. I mention this because the honest version of "how I work now" is more useful than the version where I pretend nothing has changed, or the one where I pretend everything has.

So here's the honest version.

Where the agents actually help

I don't write much code anymore. That doesn't mean I've stopped working; if anything I work differently, and probably more. My days now go into reading, planning, testing, and documenting, more of each than back when I was the one typing everything out.

The loop looks like this. I propose a feature, then talk it through with my agent across several iterations, shaping and reshaping until everything sits the way I want it. Sometimes I get most of the way there, notice something I missed, and start the whole thing over. Having something to think *against* is genuinely useful; it beats a blank file and it's less lonely than a whiteboard. It's the old rubber duck debugging trick, where explaining a problem out loud is half of solving it, except this duck occasionally hands you a working draft.

The result is a strange compression of time. Work that would once have taken me a week, I can now stand up in a day, tests and documentation included. The mechanical middle, the boilerplate and the plumbing and the tricky first pass at a type, mostly takes care of itself. What's left is the part I actually wanted to do.

Confidently Wrong

Here's the thing nobody's automating away: the judgment.

An agent will happily generate a working component that is subtly wrong: inaccessible, over-engineered, structured in a way that will hurt in six months. It doesn't know that the modal it just built traps keyboard focus incorrectly, or that the abstraction it reached for is one you'll rip out the moment requirements shift. It has read everything and decided nothing. Deciding is still the job.

This is truer in frontend than people like to admit, because so much of frontend is taste applied to constraints. Which state belongs where. When a pattern earns its indirection and when it's just showing off. Whether an interface actually respects the person using it. None of that arrives for free in the output. You bring it, or it isn't there.

余白

This site is named for a Japanese idea, 余白 (yohaku), the space you deliberately leave empty. In design it's the margin, the pause, the room around a thing that lets it breathe. I've come to think it's the right frame for working with these tools, too.

Because the strange new problem isn't scarcity; it's abundance. An agent will generate as much as you ask for, and then some. It costs almost nothing to produce ten variations, five layers of abstraction, a feature no one requested. So the scarce skill is no longer *making* things. It's knowing what to leave out. What not to build. Where to stop.

That was always the hard part of good frontend. It's just louder now.

How I actually think about it

I don't feel replaced. I feel like the boring middle of the work got quieter, while the two ends got louder: understanding the problem, and judging whether the solution is any good. Those ends are where I wanted to spend my time anyway.

So the agents stay. They're in my editor, my terminal, my planning. But the decisions are still mine, the taste is still mine, and the responsibility for what ships is still mine. That feels like the right arrangement. Not a threat, not a miracle. Just a sharper set of tools, and the same question underneath as always: is this good, and how do you know?