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?