The Parallel Lives of an AI Engineer

or: The Octopus Developer's Guide to Parallel Existence

So there's this octopus I've been thinking about. Not a real octopus (well, maybe it's real, I haven't checked) but the kind of octopus that lives in the space between your keyboard and your anxiety about wasting time.

This octopus has eight arms, obviously. That's what makes it an octopus and not, say, a very confused spider. But I read this thing once about octopuses (octopi? octopodes? I looked this up once but forgot): each arm has its own brain. Sort of. A cluster of neurons that can make decisions independently while the main brain is off thinking about... I don't know, fish philosophy or whatever octopuses think about.

The other day, I discovered I'd become an octopus.

The Abstract Universe Factory

As I wrote about recently, AI has really changed the way I build software. One Sunday, 90 minutes of scattered attention, an entire application. But that was just the beginning. It turns out, things are a lot different on weekdays.

Here's what Tuesday looks like now:
9:00 AM: Start three conversations with Claude. Three different projects. Three different universes.
9:05 AM: All three are churning. I'm making coffee.
9:15 AM: Check Universe A. It built a moon. Wrong kind of moon. "Actually, more cheese-like?"
9:17 AM: Check Universe B. Perfect. Ship it. Start the next chapter.
9:19 AM: Universe C has become sentient. Gently redirect. "Less philosophy, more shopping cart."

But I'm not actually working harder. I'm working... wider? Broader? Like a puddle instead of a well.

The Hummingbird Hypothesis

You know what's exhausting? Context switching. That's what they told us. "Don't multitask," they said. "Deep work," they insisted. And they were right. For humans.

But what if you're not switching contexts? What if you're just... visiting?

The hummingbird doesn't live at any flower. It visits. Sips. Moves on. The flowers do the work of being flowers—growing, blooming, making nectar. The bird just... coordinates. Pollinates. Enables.

The Compound Interest of Parallel Anxiety

Guilt compounds faster than code. Every moment not running parallel agents feels like... like what? Like being a single-threaded consciousness in a multi-core universe. Like having eight arms and using them to scratch one itch.

One project running while you rest? That's fine. That's Sunday.
Two projects? Okay, efficient.
Three projects? Now you're wondering why not four.
Four projects? Obviously five is possible.
Five projects? You monster, there are 24 hours in a day and you're wasting 16 of them on "sleep" and "eating" and "human connection."

My mind has become like a busy train station. Tracks everywhere. Trains arriving and departing on schedules I didn't set. Sometimes I'm the conductor. Sometimes I'm just standing on the platform, eating an overpriced sandwich and wondering when I became this person.

The Coordination Catastrophe

Here's the thing about teams now:

Two developers on one codebase is like two octopuses sharing one coral reef. Technically possible. Practically ridiculous. Everybody's arms getting tangled. Ink everywhere. The coral is screaming (coral doesn't scream, but work with me here).

But one octopus with eight projects? That's just nature.

The Tomorrow Parallelism

I used to dream in serial. One thing, then another thing, then another thing. Like a very boring computer from the 80s.

Now I dream in parallel. Eight dreams at once. In one, I'm building a compiler. In another, I'm designing a chair. In a third, the chair is using the compiler. It's confusing but productive.

The thing is: we're all about to become octopuses. Not physically (probably), but mentally. Spiritually. Professionally.

Because why wait? Why queue? Why take turns?

When you can grow arms.

The APM Revelation

Like we’ve talked about before, we're building this thing. APM (Actions Per Minute). Yes, like the StarCraft metric, because if you're going to manage a swarm of AI agents, you might as well admit it's basically an RTS game now.

Picture this: a command center where all your parallel universes live. Not tabs (tabs are where dreams go to die). Not windows (windows are just fancy tabs). A proper HUD. Like you're piloting a spaceship, except the spaceship is your attention and space is made of unfinished projects.

Always there. Always visible. Right now it gives you status updates on all your projects. But here's what clicking on a project will actually do soon: help resurrect an entire mental state.

The terminal window springs to life with Claude Code already loaded, cursor blinking at exactly where you left off. Your last three prompts float in the history, because context decay is the enemy of arm autonomy.

The conversation threads materialize—not just the main chat, but the three side conversations where you explored dead ends, debated architecture with o3-pro, and that one where you asked Gemini about octopus neurology (for research, obviously).

The music playlist resumes. Because each arm needs its own soundtrack. Arm 3 codes better to lo-fi hip hop. Arm 7 requires death metal. The main brain? Mallwave (It’s very nostalgic for the 90s).

Your posture changes. The system knows Project Alpha requires you to lean back and think, while Project Gamma needs that forward-hunched intensity. A gentle notification: "Stand up in 12 minutes." Because even octopuses need to stretch.

The mental model loads. Not just the code structure, but the why-structure. The problem you were solving. The elegant solution you almost had. The stupid bug that made you switch projects in the first place (Claude had deleted the failing tests, it’s always deleting the failing tests).

Because look, when you’re an octopus with eight parallel projects: each arm doesn't just need to remember what it was doing. It needs to remember how it was thinking. The context isn't just technical—it's emotional, creative, philosophical.

The new feature drops soon. When it does, we'll all be octopuses. Organized octopuses. Octopuses with perfect memory of which arm was doing what, and why, and what song was playing when we figured it out.