The Human in the Loop

---

In the last three months, I learned four programming languages. Not really learned — not in the way that earns the word — but I built things in Rust, Swift, Dart, and Lua that I'd never have attempted before. Things that felt out of reach suddenly weren't. New languages, yes, but also work I'd always considered too complex, too unfamiliar, too far outside my stack. Writing this article is part of that too. With Claude and Codex alongside me, nothing felt impossible. It felt alive.

But here's what I've been slower to admit: I couldn't stop.

Evenings. Weekends. Work projects on personal time, justified as enjoyment, which was partly true. The loop was tempting: describe a problem, watch it take shape, push further. Every session ended with the sense that I was one prompt away from something better. Stopping felt like leaving a game mid-level.

I'm a developer with years of experience. I know what unhealthy patterns look like. I was in one. I just didn't notice until I stepped back.

The Superpower That Isn't Quite Real

The productivity is real. Moving across languages and problem domains with an AI agent is a genuine shift. It removes the friction that normally keeps you within your familiar stack.

But there's a version of that capability that's not quite real.

I could produce Rust. I'm not sure I can own it. There's a difference between a codebase that works and the mental model to maintain it at 11pm when something breaks and the agent is hallucinating library interfaces that don't exist. The surface area I accumulated grew faster than the understanding underneath it.

What you can ship and what you actually understand quietly drift apart. Nobody's monitoring the gap — least of all you, because everything works. The tests pass. The PR is merged. But the certainty you used to have about your own work isn't quite there anymore.

The Loop You Can't Step Out Of

Normal development has long stretches of confusion and debugging that goes nowhere. The reward is irregular and delayed. Agent-assisted development compresses that: visible progress every few minutes, tireless execution, every session ending with something built.

That rhythm is closer to a slot machine than a coding session. Not because outcomes are random, but because the feedback loop is tight enough to keep you going. You're not stuck. You're shipping. That rhythm is very hard to walk away from.

The Overhead Nobody Mentions

There's another cost on top of all of this: mental overload.

A pull request that used to be 200 lines is now 2000. Not because the developer got lazy, because the agent is tireless. You can't review that properly. You scan it, run the tests, look for obvious problems, and approve. The understanding that code review is supposed to build just isn't there. The same gap, arrived at through a different door.

Context switching is the same problem. Three projects, two languages, five agents running. Every switch means reloading: what were you doing, what does this codebase expect, what are the conventions here. At some point the switching takes more out of you than the actual work. Present everywhere, focused nowhere.

This isn't a discipline problem. The tools simply produce faster than humans can absorb, review, or switch between. We don't have norms for that yet, and the people selling the tools have no reason to build them.

The Conversation We're Not Having

The industry talks a lot about what AI does. Whether the models are safe, the outputs accurate, the systems trustworthy. All aimed at the tool side of the interface.

Nobody's asking what this does to the person on the other side. The developer who picked up habits without noticing, took on more than they can maintain, and forgot where work ends and rest begins.

AI agents are becoming the default way of working. A lot of developers will struggle with the same things I'm struggling with now.

If you're recognising any of this, here's what I'm trying: set a hard stop for your agent sessions — evenings and weekends are not overflow capacity. Don't put your coding tools on your phone. Protect the relationships and routines that have nothing to do with shipping. And when the gap between what you're producing and what you understand starts growing — slow down. Use your hands. Build something without a prompt. Remember what it feels like to think through a problem yourself.