How I work now

Right now I have six terminals open. Some days it's two. On a hard one it's nine.

Each one is an agent working on a different ticket.

That's the shape of the day. I'm not sitting in a canvas. I'm moving between threads, deciding what each one should do next, and checking what came back.

Work arrives as a ticket

Everything starts in Linear. Someone on the team files it, or I do. Often I find something mid-task, something broken or missing, and it becomes a ticket before it becomes work.

That can sound like process for its own sake. It isn't. The ticket is what makes the work visible to everyone else, and it's the unit an agent can pick up. A vague intention can't be handed off. A written one can.

The repo holds the documentation

The internal documentation lives in the repo, next to the thing it describes. Not in a separate wiki that quietly goes stale.

This matters more with agents than without. An agent reads the repo. If the rules of the system are written down there, it inherits them. If they only live in my head, I retype them every session.

Quality is a script, not a review

The obvious worry about agents is quality. You get a lot of output, fast, and some of it is wrong.

Reading all of it isn't the answer. That just moves the bottleneck back to me.

So a real part of my week goes into skills and test scripts. Small, boring checks that run on their own. Does this follow the pattern we agreed on? Does it pass? Does this copy break a rule I set six months ago and forgot?

This site has one. There's a script that checks every article against how I write, and it fails the build if I slip. I wrote the rules once. Now they hold without me.

Once a check exists, it runs every time, on work I never see. That's what makes the volume safe.

A place for the humans to look

Not everything should be read in a terminal. So there's an internal area only the team can reach. Documentation in a form built for people rather than for parsing. Assets generated, previewed, and exported from the same place.

On the repos that ship product, that area holds the components too. Same idea as Storybook, built by us instead. Lighter, and it doesn't have opinions about how we work.

Design systems rot because the source of truth and the thing people actually look at are two different objects. Here they're one object, rendered twice.

It doesn't live on my laptop

Some of the agents run in the cloud and are reachable from Slack. Work can start without me being at the desk. I read a thread on my phone, decide, and send the action from there.

Which makes counting my open terminals a bad way to describe any of this. More of it runs where I can't see it, and that's the direction it keeps going.

It changes what counts as being at work. The expensive part was never the typing. It was the deciding, and deciding travels.

The systems are wired together

Call notes come out of Granola. The rest of the tools are connected too.

The point isn't automation. It's that when I ask a question about a customer, the answer comes from what actually happened, not from what I remember happening. Product intuition is pattern matching over a lot of context. So I give the context to the thing doing the matching, and to myself.

Where it falls down

The vision never gets delegated. What to build, why, what it should feel like, which details matter. None of that comes back right when I hand it over, and I've stopped trying.

The details are the slow part. An agent gets close, and then the last 10 percent takes a lot of iterations. Getting all the way there takes longer than people expect.

The bigger risk is quieter. If you don't set the direction up front, the first thing that comes back becomes the direction. It looks reasonable, so you build on it. Now you're working inside a point of view you never picked.

So I often design the first version by hand and pass that over as the starting point. A blank page is where they're weakest, and it's where they fill the gap with taste of their own. Give them something that already has a point of view and they run with it.

The automation isn't free either. Every skill and every check took time to write, and most were wrong before they were right. You pay up front for something that pays back later, and not all of them pay back.

And the only way to find the edges is to keep hitting them. You have to use these tools a lot, on real work, to learn what they're bad at. Nobody can hand you that map.

Whether it should exist at all

This goes past agents. More of the work arrives already made now. A screen, a flow, a draft, an answer. It shows up finished enough to be taken seriously, and that's the problem.

A door being there, and being well made, doesn't make it the right door. It doesn't mean a door belongs there at all.

Improving something that shouldn't exist is worse than leaving it alone. Now it's good, so nobody asks about it again.

So you question everything, more than you used to. Not as a pose. The cost of skipping it went up.

The part that transfers

None of this is a stack worth copying. The tools will be different in a year, and half of these names will be gone.

What transfers is the move underneath it. Every time I catch myself making the same call twice, that's a thing to write down somewhere it can run without me. A check, a script, a page of documentation, a rule.

The work isn't making the screens anymore. It's building the thing the screens come out of, and being right about what should come out.