Where did the flow go?

Agents took the struggle out of coding. The struggle was the fun part.

Where did the flow go?

I was listening to Derrick Reimer on The Art of Product the other day, and he said that the thing he misses most about coding is listening to music while he does it.

That's it. Not the code, not the bugs, not the stand-ups. The music.

It sounds like a throwaway comment, but it sent me down a rabbit hole, because for months I've been hearing a version of the same thing from people on my team: work has become more taxing and less fun.

Which is strange, if you think about it. We have basically been handed godlike powers. You think of a feature, and a few hours later (sometimes minutes) it exists. This should be the best time EVER to be a developer. So what gives?

The obvious answer is code review. If you're not writing the code anymore, you spend your day reading it, and I have yet to meet a developer who got into this job because they love reviewing other people's pull requests.

That's definitely part of it. Here's the problem though: review is being automated too, and quite fast. If reviewing were the whole story, the problem would fix itself in a year or so. I'm pretty sure it won't, because I think the real culprit is something else.

Chiselling

When we wrote code by hand, we were slow. Painfully slow, by today's standards. But the slowness came with something else: long stretches of thinking really hard about one problem, and chiselling at it, line by line, until it gave way.

That's what psychologists call flow, the state Mihaly Csikszentmihalyi spent his career studying, where you're fully absorbed in something hard enough to stretch you but not hard enough to break you. And it feels GREAT. I think flow is what developers loved about the job.

Agents take it away in two ways.

The first is interruptions. Working with agents is a loop: write a prompt, wait, read the output, redirect, wait again. The waits are the worst bit. Ninety seconds is too short to do anything useful and too long to stay inside the problem, so you drift to Twitter, or you start a second thread. Then a third. Each thread makes you faster, and each one costs you a context switch. In other words, we're objectively quicker than ever and subjectively more scattered than ever. Paul Graham wrote about the difference between the maker's schedule and the manager's schedule back in 2009, and agents have quietly (well, not that quietly) put every developer on the manager's one.

And that's why you can't listen to music anymore. You could when you were chiselling. You can't when you're constantly judging someone else's output.

The second is the escape hatch. Flow needs struggle, and struggle needs no easy way out. An agent is a permanent easy way out: the moment something gets hard, you can hand it off, and your brain (being a lazy organ, like everyone's, mine included) will take that exit every single time.

This also explains something that confused me for a while: why I haven't felt this loss as much as my team. Turns out the answer is boring. I stopped coding a long time ago. I swapped flow for managing people and reviewing work years before agents showed up, so I already went through this, slowly and by choice. My team is going through it all at once, and nobody asked them.

Don't blame the agents

Don't get me wrong: I'm not saying agents are bad and we should go back to typing everything by hand. We shouldn't, and we won't. I'm saying the struggle has to move somewhere else.

Right now, the obvious place is one layer up: architecture, data modelling, the nasty debugging that agents still fumble. But let's be honest, that's a staging post, not a destination. We're slowly (but surely) heading towards a world where a developer won't even hold the full data model of the app in their head. Whatever layer humans still own is where the hard thinking has to live, and that layer keeps rising: deciding what should exist and why, and judging whether what got built is actually any good.

My bet is that the hard thinking moves to user experience. I don't mean the buttons and the colours (agents are already pretty good at those, and they've read every onboarding best practice ever written). I mean how people actually use the thing: where they get stuck, what confuses them, what makes them fall in love with an app instead of just putting up with it. That takes watching real people, caring about the outcome and a decent amount of taste, three things agents are, for now, pretty bad at.

Here's the catch though: taste only gives you flow if you use it to make something. If the agent spits out five "delightful" versions of a feature and you pick one, congratulations, you're reviewing again. Sit with a user, watch them struggle, form a hunch, sketch the fix yourself. That's where the chiselling is now.

Speaking of which, there's a parallel I can't stop thinking about. When physical labour disappeared from most jobs, people didn't stop needing to exert themselves. They invented the gym, a place where you pay money to lift heavy things for no reason other than the lifting. We might need the brain version of that.

How to get the flow back

I don't have this figured out (I stopped chiselling years ago, remember?), but I'm convinced of one thing: if you don't protect your flow on purpose, the agents will eat it for you. So here's what I'd do.

  1. Think before you prompt. The moment you open the agent, the struggle is over. So don't, at least not straight away. Start every meaningful piece of work with a block of proper thinking (a doc, a whiteboard, the edge cases, the bit you're unsure about) with no agent in reach. That's the new chiselling.
  2. Stop babysitting. The ninety-second loop is the enemy. Give the agent a bigger, better-specified chunk of work, let it run, and come back when it's done. Then review the lot in one go instead of drip-feeding your attention all day. Two threads at most: the fourth one feels productive, but mostly it's costing you focus.
  3. Go and watch a human. Not the dashboard, an actual person using what you built. It's the fastest way I know to find a problem worth struggling with.
  4. Do something hard by hand, on purpose. Every now and then, pick a problem and solve it yourself. It's slower, and that's exactly the point. Think of it as the gym.

We never really loved typing. We loved thinking hard about something until it cracked. Agents have made that optional. But thinking hard works like a muscle: use it or lose it. And if you lose it, the fun goes with it.

Put your headphones on and try it :)