It's a build day. I'm a couple of hours into a stack of tickets with my agents when a stakeholder pings me on Slack with a feature request. It's a good idea, too, which is the dangerous kind.

Unless it's clearly an urgent showstopper, it waits. I finish the build day, and the request goes into intake with everything else, to get prioritized later against everything else. That one habit is most of what I've learned about holding two jobs at once, and it took me longer to learn than I'd like to admit.

For the last three months or so I've been doing something I hadn't done professionally in a very long time: building. On a client project I'm the developer, doing the whole thing agentically. I'm also the one who decides what gets built, in what order, and owns every seam around it. Builder and operator, one head.

I wrote a few weeks ago that this is harder than it looks and promised the tactics their own post. Here it is. Fair warning, my tactics are still evolving, so take this as a field report.

‍

Everyone's a Builder Now

You've probably seen some version of the story. Tomer Cohen, who spent six years as LinkedIn's Chief Product Officer, replaced their associate PM program with "full stack builders": one person who takes an idea all the way to launch, with agents and a team. Founders are posting that they're back in the code. Job descriptions are folding three roles into one.

The building really did collapse into one person. I'm living proof, and I'm not here to argue with it. (Tbh, it's pretty fun.)

What I find more interesting is what Cohen said about the parts that didn't collapse. In a recent talk (recapped on Miro's blog) he called coordination the piece nobody has cracked: "Coordination is not easy." Speed multiplies inside each silo, and so does misalignment, until something breaks. And the skill he said holds its value is judgment, whether you're able to make the call.

So the most prominent advocate of one-person building names the seams and the call as the unsolved part. That's the Operator Seat.

‍

AI made the building cheap. Judgment and coordination are still the long pole.

‍

I Run Myself Like a Team

I can't wear both hats at the same time. I've tried. Building is reactive: you get a list and you work the list. The Operator Seat is proactive: deciding what goes on the list, and spotting the seam before something falls into it. When I try to do both in the same hour, the list wins every time, because the list is loud and the seams don't ping you.

So I swap hats on purpose, and I timebox the day to make room for both.

What's worked best is treating myself plus my agents as a team, the same way I ran dev teams before AI. That means the boring fundamentals, still:

  • There's a ticketing system. Yes, I am opening tickets for myself, and then closing those tickets out... myself.
  • The work is split in two: big boulders, and pebbles and sand. (If you remember the jar-of-rocks demo, you know why the boulders go in first.)
  • Every item gets a P1, P2 or P3. No P0.5s, even when I'm tempted.
  • Build days are build days. New intake waits unless it's on fire, then gets prioritized with everything else.

None of that is new, and I think that's why it works. The fundamentals that made a team of six work still make a team of one-plus-agents work, and skipping them because "it's just me" is how I'd end up building whatever pinged me last.

‍

I Haven't Looked at the Code in 20 Years. Why Start Now?

When I managed dev teams, I wasn't in the technical weeds. I made calls on behavior: what the product should do, what done looks like, whether something smelled off. I'm the same with my agents. I haven't looked at code in a professional build in about twenty years, so I'm not starting now.

That sounds like a recipe for the Agentic Fog, where you produce more than you can actually understand. My answer has been to lean harder into treating the agent as a teammate, with the same habits I'd use with a developer.

I ask how things work. Recently an agent built a state machine, and some of the business logic sounded like logic that lived elsewhere in the app. So I asked: "Did you build it twice or is it in a common module?" One place. Good answer. I'd have asked an engineer the exact same question.

I also keep the lines of communication open. The agent only knows what's inside its own world. If priorities change, or I've made a call in a client meeting, or something shifted outside the code, I tell it, same as I'd catch up a developer who missed the meeting.

Sanity checks and behavior, the same as always. The agent is fast, but it still needs someone in the Operator Seat telling it what matters this week.

‍

The Elephant in the Room

If no human is reading the code, how do you know it's OK?

For now, you mostly don't, and I'm upfront about it. So I keep my solo build work to proof-of-concept territory, venturing into MVP at most. That's by design. Getting something to proven is cheaper with one person who can hold both views, if only one at a time.

As soon as something has enough traction that the client wants to scale it, that's the signal to bring in a human engineer to run the agents, so I can put all my attention on the Operator Seat.

I've already done this once. For an internal tool at a company I work with, I did the proof-of-concept build myself. Once I was clear on how the tool should really behave, I handed development to an engineer on their team. Now I spend my time using the tool and making the strategic calls about it, which is the job I was actually hired for. The current client build is headed the same way, probably early next year.

The handover goes to an engineer who can run the build. Hiring a project manager to track my tickets would have been the Hire Trap all over again. The Operator Seat stays with someone whose whole job is that seat.

‍

If You're the Founder Back in the Code

Founders are the original two-hats people, and a lot of you are back in the code right now with a coding agent and a full head of steam. I get it, and the agent will happily keep you busy all day.

But every hour you spend heads-down is an hour nobody is in the Operator Seat at your company. That's an Operator Vacuum you created on purpose, one build day at a time. It's the Founder Bottleneck at agent speed: more getting built, less getting looked at.

So here's the check. Look at what got built this week and ask who put it on the list, and when. If the honest answer is "whoever pinged me last," the list is running you.

The handover depends on finding the right engineer, and I'm less worried about that part than a lot of people seem to be. My bet is that AI changes what the junior rungs look like for engineers, the same way every jump to a more abstracted way of coding has, and those engineers will pick up their scar tissue like the rest of us did. So the engineer who takes over doesn't have to be super senior, just someone past their very first project.

The Operator Seat is different. It's a high-judgment job, and judgment takes experience, by definition. I haven't found a way to make it a junior position yet, and honestly, I'm not sure it should be one. Let's face it, the person you trust to be your first officer isn't the place to cut corners on cost. But I'm open to anyone who can prove me wrong.