Dopamine-Driven Development: When the Machine Keeps Whispering One More Prompt

The New DDD

Software engineering loves its three-letter acronyms. We've had TDD (Test-Driven Development), BDD (Behavior-Driven), and the venerable DDD — Domain-Driven Design, Eric Evans' 2003 masterpiece about aligning code architecture with business reality.

I want to introduce a new DDD. One that nobody designed. One that emerged, bottom-up, from the collision of large language models with human neurochemistry:

Dopamine-Driven Development.

It's the development methodology you didn't choose but are already practicing. Every time you prompt, get a working result, feel the rush, and prompt again. Every time the 20-minute task becomes a 20-hour session because the feedback loop is so tight, so rewarding, so frictionless that your prefrontal cortex — the part of your brain responsible for saying "enough, go to bed" — simply loses the argument against the nucleus accumbens, the part that says more.

If you've built anything with Codex, Cursor, Claude Code, Windsurf, or Copilot in the last year, you know exactly what I'm talking about. And if the phrase "I was up until 2 AM prompting" sounds familiar, you're not alone. The team at Pydantic — the people who literally build the tools we use to make LLM software more reliable — feel it too.

The Neuroscience of the Tight Loop

Here's what's happening in your brain, and it's not metaphorical.

Dopamine is often mischaracterized as the "pleasure chemical." It's more accurately the anticipation chemical — the neurotransmitter that fires not when you receive the reward, but when you expect one. Wolfram Schultz's foundational work on dopamine prediction errors, published in the late 1990s at Cambridge, established that dopamine neurons fire most intensely in response to unexpected rewards. When a reward arrives predictably, the response flatlines. When it arrives unpredictably — sometimes brilliant, sometimes garbage — the system goes into overdrive.

Sound familiar? It should. It's the exact architecture of an LLM-assisted coding session.

You prompt. Sometimes you get a working app. Sometimes you get hallucinated imports and invented APIs. You never know which. This is, neurologically, the same variable-ratio reinforcement schedule that drives slot machines, social media feeds, and — as B.F. Skinner demonstrated decades ago — the most addiction-prone behavioral patterns in mammals.

The old coding loop was different. You wrestled with a bug for hours. You questioned your life choices at 2 AM. Then you fixed it, and the dopamine hit was singular, massive, earned. The struggle was the price; the solution was the reward. That loop had natural braking mechanisms built in: frustration, confusion, the physical fatigue of thinking hard. These weren't bugs in the process. They were features. They were the friction that told your brain: time to stop, rest, synthesize.

LLM-assisted development removed the friction without removing the drive.

What the Research Says

The anecdotal evidence is everywhere. But the rigorous evidence has arrived too.

In February 2026, UC Berkeley Haas researchers Aruna Ranganathan and Xingqi Maggie Ye published their findings in Harvard Business Review from an eight-month ethnographic study of 200 employees at a U.S. technology company. Their conclusion was counterintuitive and devastating: AI doesn't reduce work. It intensifies it.

They found three mechanisms of intensification. First, scope expansion: people began taking on tasks that would previously have belonged to someone else, because AI made starting them feel trivially easy. Second, temporal bleed: work seeped into moments that used to function as pauses — prompting during lunch, before meetings, in the evening when an idea came to mind. The natural stopping points in the workday dissolved. Third, thread proliferation: workers ran multiple AI processes simultaneously, keeping numerous tasks alive at once, context-switching continuously between their own thinking and AI outputs.

What surprised me most was the contrast between how people described their moment-to-moment engagement and how they described their overall experience. In micro-moments, people talked about momentum and expanded capability. But when they stepped back, a different tone emerged. They described feeling busier, more stretched, or less able to fully disconnect.

— Xingqi Maggie Ye, UC Berkeley Haas, HBR, February 2026

Meanwhile, ActivTrak's analysis of over 164,000 workers found that after AI adoption, time spent on email and messaging more than doubled, business software usage surged by 94%, but focused, uninterrupted work time fell by 9%. The capacity AI freed up didn't go to rest or reflection. It got immediately repurposed into more work.

This is the paradox of Dopamine-Driven Development. It feels like empowerment while it erodes sustainability.

The Human-in-the-Loop Is Tired

Laura Summers at Pydantic wrote what I consider the essential text on this moment. In her February 2026 essay "The Human-in-the-Loop Is Tired," she described a peculiar new form of fatigue: the fatigue of supervision.

Her colleague Douwe — who maintains the Pydantic AI framework — described waking up to thirty pull requests every morning, each generated overnight by someone's AI assistant, needing snap judgment calls on every one. The temptation to delegate the review itself to another AI was enormous. But as he put it: "at that point, what am I still doing here?"

Summers named the core problem: the human reward function problem. Writing code by hand was never easy, but it was full of small rewards — solving a problem in your head, understanding a gnarly bit of logic, watching the code compile, the feeling of control. LLM-assisted programming automated much of the work that generated those dopamine hits and replaced it with the cognitive load of review and supervision. The satisfying part shrank. The exhausting part grew.

And then she named the thing nobody was saying: it's lonely. Programming with an LLM is an intensely solitary activity. You and the machine, going back and forth. The natural moments where you'd turn to a colleague — to rubber-duck a problem, to share the small victory of something clicking — get quietly replaced by another prompt.

This describes my own experience building CiudadanIA, the citizen correspondence system that runs on locally fine-tuned Qwen3-4B for privacy-by-design. I spent entire weekends iterating on system prompts — prompting, testing, adjusting, prompting again — in a loop so tight that by Sunday evening I'd done genuinely impressive work but couldn't remember eating lunch. The number of things I could start had dramatically increased. The number of things I could thoughtfully finish hadn't changed at all.

The Cambrian Explosion of Co-Creation

But here's where I refuse to write the doomer essay.

Because the thing that kept me up until 3:47 AM? It worked. ServetIA works. CiudadanIA processes citizen correspondence in production. PromptAventura gamified AI literacy for government employees. GlobalAlert tracks multilingual misinformation in real time. In one year at PresidencIA, a team that would be considered microscopic by any government standard shipped applications that would have taken departments of fifty people and eighteen months of procurement cycles.

This is the other side of the DDD coin, and it's real. We're living through what can only be called a Cambrian explosion of co-creation between humans and AI systems. The biological Cambrian explosion — 541 million years ago — was triggered by a convergence of environmental conditions that suddenly made rapid diversification not just possible but inevitable. Eyes, limbs, and complex nervous systems emerged in parallel across multiple lineages in a geological eyeblink.

The same convergence is happening now. LLMs sophisticated enough to generate working code. Context windows large enough to hold an entire project. Agent frameworks that can execute multi-step plans. Voice interfaces that let you talk to your IDE. All arriving simultaneously.

Y Combinator reported that 25% of startups in their Winter 2025 batch had codebases 95% generated by AI. Karpathy coined "vibe coding" in February 2025, watched it become Collins Dictionary's Word of the Year by November, then declared it passé by February 2026 — replaced by "agentic engineering." In 14 months, the entire concept went from tweet to dictionary to obsolescence. That's not a hype cycle. That's a phase transition.

At Saturdays.AI, I've watched people with no formal programming background build functional AI applications in weekend workshops. Things that would have required a team of engineers five years ago. The creative democratization is genuine. The dopamine isn't lying to you about the magnitude of the moment. The magnitude is real.

The Dual Nature of DDD

Toward an AI Practice

The Berkeley researchers proposed something I find compelling: not AI use, but an AI practice — a deliberate set of rhythms and boundaries around AI-enabled work. The word "practice" is chosen carefully. Like a meditation practice or a medical practice, it implies intentionality, discipline, ongoing calibration.

Here's what an AI practice looks like for me, refined through a year of building with AI at government scale:

The Builder's Dilemma in the AGI Era

There's a deeper philosophical tension I don't want to paper over.

If you believe — as I do, as the trajectories suggest — that we're in the early stages of something that may produce artificial general intelligence within years rather than decades, then the imperative to build is not just professional ambition. It's a civilizational necessity. Someone has to build the verification infrastructure, the safety frameworks, the institutional capacity to govern systems that are getting smarter every quarter.

That's the dilemma. The same urgency that makes this work important also makes it addictive. The feeling that you're running out of time to shape the future activates the same dopaminergic circuits as the coding loop itself. Momentum and anxiety become indistinguishable. And the AI, ever helpful, ever available, never tired, never judging, is right there with another suggestion, another iteration, another 2 AM session disguised as purpose.

I don't have a resolution for this tension. What I have is the conviction that naming it matters. That recognizing Dopamine-Driven Development as a pattern — not a personal failure, not a character flaw — is the first step toward managing it.