Working alongside the machines without losing sanity

Over the past year or so, I've converged on an approach on working alongside AI that I haven't seen coherently described elsewhere.

Distinction between tactics and strategy

As Ethan Mollick explains, you can never outsource your strategy. This doesn't necessarily hold because human judgment is somehow magical and inherently valuable (I wish it were), rather that what we refer to as strategy is the application of the human value function on long-horizon tasks; whether you picked the right strategy is only clear after months or years, and even if it has failed, failure is overdetermined. Thus it's very hard to teach agents to do seemingly not-Fields-medal worthy tasks such as running a gas station, hiring and firing, or setting which goals are worth pursuing. (I also don't expect agents to get much better at these tasks soon.)

Delegation

As agents become increasingly more competent and trustworthy, all ICs are facing the challenge of learning to delegate to them. You as the human will quickly become the bottleneck if you insist on micromanaging the AI.

New tech debt

Tech debt used to mean dependency updates, spaghetti code and refactors, all of which are rapidly becoming very tractable tasks for the intelligences ("bug-for-bug refactor").

Tech debt now is the part of your codebase where you don't feel comfortable having agents run around without you looking directly over their shoulder. Just as tech debt slowed you down in worse DX, new tech debt slows you down by making it hard to delegate. The optimal amount of new-type tech debt, as it was for the old type, is nonzero.

The codebase, CI and testing strategy foolproof enough that you feel comfortable judging whether the agent (which lacks judgment) has succeeded. Once you can reliably verify the final output, you can delegate.

Bimodal cooperation -- deep work and delegation

We've established that once the goal is clear and well-defined, and the area of code that is to be touched is is not new tech debt, one should delegate. In my experience, the median length of an agentic turn is a good joint indicator of the operators' agentic prowess and new tech debt in the codebase.

There (luckily!) are many places where you it's unwise to delegate -- typically specs, interfaces, rules, workflows, state migrations, infrastructure decisions, or just the out-of-domain truly novel problems. These tasks are best done in flow state, and for a flow state, one needs a completely different way of working with the agent. I refer to this role as the librarian -- the librarian's job is to feed me resources so I can build an understanding, a model of the problem, and work on the non-delegatable problems.

The delegate should be primarily diligent, reliable, trustworthy, and able to unblock itself. Slow models like GPT 5.6 Sol on the higher effort levels work well for this usecase.

The librarian must be fast -- it mustn't give me time to switch to reading Twitter before its response arrives. For this purpose, I've been enjoying Gemini in Antigravity, which currently runs at a blazing 300 tps.

How it feels

I feel that I've finally found the durable place for the human in the software workflow -- the exact level of where we place the strategy vs tactics distinction will change over time, but the shape of deep work vs work worth delegating is likely here to stay.