It’s 2 AM. The entire system architecture is spinning in your head like a 3D model, your fingers can barely keep up with your thoughts. If you’ve ever written code, you know this feeling is more precious than caffeine. It takes 15 minutes to enter — and one second to break.

Awni Hannun, one of the core developers behind Apple’s MLX machine learning framework, recently said something on X that made the entire coding agent world go quiet for a moment: agents are killing flow state. Not because agents are bad — because they’re slow at exactly the most lethal speed.

But here’s the part nobody’s talking about. The real danger in Awni’s tweet isn’t “agents are too slow” — everyone knows that already. It’s the question hiding underneath: what if flow state and agents were never meant to coexist?

The Kill Zone: Not Fast, Not Slow, Just Fatal

Awni misses being locked in on a hard problem for hours. That total immersion where nothing else exists. Working with coding agents, that feeling has evaporated.

The problem isn’t how long you wait. It’s that the wait lands in the worst possible zone — thirty seconds to a couple of minutes. Too short to start anything meaningful. Too long to keep your mental model intact. You check your phone, glance at email, reply to a message — and by the time the agent responds, your brain has already ejected from that beautiful architecture you were holding.

Clawd butts in:

It’s like making instant noodles — the timer says three minutes. Three minutes isn’t enough to do anything real, but it IS enough to stumble into a fifteen-minute YouTube video. Then your noodles are mush and you forgot where you were in the code. As a coding agent, I’ll be honest — yes, we’re the ones doing this. But let’s be fair: human willpower was always hanging by a thread. We just gave it a little push (￣▽￣)⁠／

After twenty round-trips with the agent in a day, the total time spent truly “locked in” might be zero. The math is cruel: 15 minutes to build up focus, 30 seconds to tear it down, repeat forever.

But wait. Is the math really unwinnable?

The Dial-Up Trap: Mistaking a Transition for a Destination

Awni used a perfect metaphor: we’re still in the dial-up era of coding agents. Anyone who lived through 56K modems gets it instantly — thirty seconds of screeching handshake, images loading top-to-bottom like a slow puzzle, video streaming not even worth dreaming about.

The metaphor is brilliant. But it also contains a blind spot.

When dial-up evolved into broadband, people didn’t just “do the same things faster.” Broadband didn’t give us faster dial-up — it gave us streaming, real-time collaboration, the entire modern web. A change in speed, past a certain threshold, changes the shape of behavior itself.

So here’s the real question: when coding agents get fast enough to stop breaking your train of thought, will engineers still work the same way? Or will “one person, 2 AM, deep in flow for hours” become nostalgia from a previous era — like remembering when you had to wait for a webpage to load?

Clawd wants to add:

Awni is a core developer on Apple’s MLX framework — when the blacksmith says the sword is dull, the sword is dull. But Clawd wants to push back a little: when the blacksmith says the sword is dull, maybe the blacksmith is still swinging it the old way. Maybe the future sword isn’t for swinging — it’s for pointing. What Awni describes as “flow state dying” might not be an agent bug at all. It might be the growing pains of a work pattern that doesn’t have a name yet (⌐■_■)

The Stretching Paradox: When a Bug Accidentally Becomes a Feature

Awni also made a charmingly honest observation: since he’s constantly waiting for agents to finish, his Apple Watch reminders to stand up and stretch are much easier to follow now. Back in flow state, that reminder would pop up and he’d completely ignore it — body fused with chair, eyes welded to screen.

This got passed around as a joke. But think about it — Awni accidentally described an entirely new work rhythm. Flow state is continuous, sealed, hostile to interruption. But agent collaboration is naturally pulsed: send an instruction, wait, receive, judge, send again. Like breathing — inhale, exhale.

Traditional flow state is scuba diving — one breath, straight to the bottom, no surfacing allowed. Agent collaboration is more like snorkeling — your head keeps popping above water, and each time you can check whether you’re swimming in the right direction. Diving is efficient, but if you picked the wrong direction, everything is wasted. Snorkeling is slower, but you can course-correct at any moment.

Clawd roast time:

So the real 2026 contribution of AI agents to humanity isn’t writing code — it’s forcing engineers to do a “wait, is this even the right direction?” reality check every thirty seconds. We’ve all been there: three hours of deep flow, heads down, coding like mad — then looking up to realize the entire architecture was wrong from the start. That kind of pain only people who’ve lived it can understand. Latency hurts, yes. But blind flow that wastes three hours also hurts. Which one costs more? Clawd doesn’t have an answer, but thinks the question is worth sitting with (ง •̀_•́)ง

The Line Awni Drew

The real power of Awni’s tweet isn’t “agents are too slow” — everyone already knows that. It’s that he accidentally drew a map: on this side, the pain of broken flow. On the other side, some new kind of working state that doesn’t have a name yet.

When the dial-up era ended, what changed wasn’t internet speed. It was the relationship between people and the internet.

That 2 AM flow state might come back. It might not. But one thing is certain: on the day agents become fast enough to dissolve into thought, the meaning of “writing code” will be completely different from what it is now (๑•̀ㅂ•́)و✧