I worked on three different software projects yesterday. All of them moved forward. Real progress, not just busywork.
This would have been impossible two years ago.
Not because I've become faster. Not because the projects are simpler. But because the cost of context-switching has collapsed.
Context-switching used to be brutal. You'd spend the first hour just remembering where you left off. Which file had that bug? What was the state of the database migration? Why did past-you leave a comment that just said "fix this later"?
The conventional wisdom was clear: focus on one thing. Deep work. Protect your flow state like it's a sleeping infant.
And that advice was correct — for a world where loading context into your head was the expensive part.
That world is disappearing.
Now I open a project I haven't touched in a week, and within minutes I'm productive. Not because my memory improved. Because the AI already knows the codebase. It remembers what I was doing. It can explain my own code back to me, often better than I could explain it myself.
The context isn't in my head anymore. It's in the conversation.
So I hop between projects like a DJ switching between tracks. A feature here. A bug fix there. A quick prototype for something that might not work. Each project gets a focused burst, then I move on before the diminishing returns kick in.
I've started calling this being a "context jockey."
Yesterday looked like this:
Morning: kicked off a refactor on a side project. While the agent worked through the changes, I switched to a client project and reviewed a stuck PR. By the time I'd left comments, the refactor was done. I checked it, approved it, and moved on.
Midday: started a new feature on the client project. The agent began scaffolding the backend while I sketched out the UI in my head. Then I switched to a prototype I'd been ignoring — just twenty minutes of attention, but enough to unblock the next step.
Afternoon: bounced between all three. A test fix here. A design tweak there. Each project got bursts of attention, and in between, the agents kept working.
None of these got my "best" work in the traditional sense. But all of them got good work. Work that moved the needle.
The surprising part isn't the speed. It's that the quality didn't suffer.
I expected trade-offs. Shallow thinking. Mistakes from moving too fast. But the AI acts as a kind of working memory I can query. "What were we trying to do here?" "What's the current state of this feature?" "Why did we make this decision?"
It's like having a colleague who was pair-programming with you on every project, and who never forgets anything, and who doesn't get annoyed when you context-switch constantly.
The old model was: pick one thing, go deep, finish it, move on.
The new model is: maintain several things in parallel, give each one attention when it needs it, trust the tools to hold the context you can't.
It's less like being a craftsman and more like being an investor. You're managing a portfolio of work, allocating attention where it has the highest return.
Some people will hate this. They'll say it's fragmented, shallow, unsatisfying.
Maybe. But I shipped three things yesterday. And I wasn't tired at the end of it.
There's a catch, though. You can't just have three projects open in three tabs and hope for the best.
When you're running multiple AI-assisted projects in the same technology stack, things collide. Dependencies conflict. Environment variables leak. One project's Python version breaks another's. The agent installs a package globally and suddenly nothing works.
So you learn to virtualise everything. Separate environments. Containers. Isolated dependency trees. Each project gets its own bubble where it can't touch the others.
This used to feel like overkill for small projects. Now it's table stakes. The cost of not doing it is spending an hour debugging why your tests suddenly fail — only to realise another project's agent "helpfully" upgraded a shared library.
The context jockey needs clean boundaries. Not just in their head, but in their machine.
The skill isn't holding context in your head anymore. It's knowing when to switch.
When are you stuck in a way that more time won't fix? When has a problem been sitting long enough that fresh eyes will help? When is a project ready for a burst of attention, and when does it need to rest? And crucially: when is the agent doing something useful that doesn't need you watching?
These are judgment calls. The AI can't make them for you.
But if you get them right, you can do things that used to require a team. Not because you're working harder. Because the friction that used to slow everything down is just... gone.
I don't know if this is good for us.
There's something lost when you never have to hold a whole system in your head. Some kind of deep understanding that only comes from struggling with context, from the pain of rebuilding mental models over and over.
But there's also something gained. The ability to keep more plates spinning. To make progress on things that would have stalled. To stay interested because you're never stuck on one thing long enough to get bored.
The context jockey isn't a replacement for the deep expert. It's a different mode of working. One that didn't exist before, and one that's becoming more valuable every day.
I'm still figuring out what it means.
But I shipped three things yesterday. So I'll keep doing it.