Recently, I realized something uncomfortable:

AI is eating my attention.

Not in the usual way, like social media or short videos. This is different. It feels productive. It looks productive. There are terminal windows running, agents making changes, files being created, commits stacking up.

Everything is moving.

But somehow, by the end of the day, nothing is really finished.

I had multiple agent coding sessions running at the same time. One was building a feature, another was fixing a bug, another was exploring an idea I suddenly had while waiting. It felt like I was doing a lot.

But when the agents came back, I did not even have the energy to validate one of them properly.

That was the part that felt wrong.

I was not blocked by implementation anymore. I was blocked by my own ability to observe, judge, and continue.

With AI, it is easy to feel super-powered.

You start to believe you can finish more than before. And in one sense, that is true. AI can write code faster than me. It can fix compile errors, generate tests, refactor files, and create UI faster than I could by hand.

But the bottleneck has moved.

The bottleneck is no longer only execution.

The bottleneck is the human context window.

Even AI has a context window. Humans have one too. Mine is not infinite. Once there are too many unfinished things in my head, I start losing the ability to make good decisions.

The funny part is that I did not hit this limit because I had less time.

I hit it because AI gave me more time.

Before AI, while I was fixing compile errors or manually testing something, my brain was still inside the same problem. The work was slower, but the context stayed warm.

Now, AI can take over many of those steps. Suddenly there is a gap. Five minutes here. Ten minutes there.

And if I do not have a clear plan for that time, my brain naturally reaches for the easiest thing:

start another idea.

For me, especially at work, starting is very easy. There is always another small improvement, another tool, another feature, another experiment. Starting feels light. Finishing feels heavy.

AI makes starting even cheaper.

That is dangerous.

AI can generate good results, but most of the time it generates good-enough results.

To make the result actually good, I still need to observe carefully. I need to read the diff. I need to test the behavior. I need to notice what feels off. I need to decide what to keep, what to reject, and what direction to give next.

That part cannot be fully outsourced.

At least for the kind of work I care about, the human is still responsible for taste, judgment, and direction.

And when I have ten unrelated things running at the same time, I cannot do that job well.

I cannot behave like a good CEO of my agent team.

I lose patience. I skim instead of reading. I approve things too quickly. I forget why I started something. My follow-up instructions become vague, and vague instructions create vague results.

By the time one agent finishes, my context has already been eaten by the things I started while waiting.

So I end the day with ten started things and zero finished things.

It feels busy, but it is actually stressful and depressing.

So I started treating my own attention like an engineering system.

We talk a lot about context engineering for AI: what to put into the prompt, what files to include, how to preserve memory, how to avoid context pollution.

But I think we also need context engineering for humans.

For me, the rule is simple:

I do not keep more than three active workstreams in a day.

Not three tiny tasks. Three meaningful workstreams. A feature, a bug, a design change, a piece of writing, a planning problem. Something that requires real judgment.

Before I start one, I spend 20 to 30 minutes doing the old-school thing:

I think.

I write down what needs to happen. I break it into steps. I decide what can be delegated to AI and what still needs my attention. I make the validation points clear.

Then I let AI do the parts it is good at.

But while that workstream is active, I do not randomly open five new ones.

If an idea appears, I do not suppress it. I also do not start it immediately. I put it into a side note.

Sometimes several ideas are actually the same theme. Performance optimization. UI polish. Better test coverage. Better onboarding. When enough of them accumulate, they become a future workstream.

This sounds simple, almost too simple.

But it works.

The result is that I am less overloaded now.

More importantly, I actually finish more than before.

The strange lesson is that AI did not teach me to run more things in parallel. It taught me to be more careful about what I keep inside my head.

I still miss the old flow sometimes.

That feeling when your cursor jumps between editor and terminal, and your thoughts slowly turn into code through your own hands. I liked that rhythm. I still do.

But that is not the only way of building anymore.

The new rhythm is different. More planning. More reviewing. More directing. Less typing. More judgment.

I won’t judge if this is better or worse.

But it does require a different discipline.

In the agent era, maybe productivity is no longer about how many things I can start.

It is about how many things I can still understand well enough to finish.