The AI Slot Machine

It's 3am. I'm sitting in the dark, watching a cursor blink, waiting for an AI agent to finish a task I asked it to do twenty minutes ago. I don't need to be awake for this. There's nothing I can do to make it go faster. But I'm still here, because in a minute it might come back with something extraordinary, and I want to see it the moment it does.

I've started calling this the AI slot machine. I've never found casinos interesting. I don't have a gambling bone in my body. But here I am, pulling the lever at 3am, telling myself one more spin might result in success.

I'm not an AI coding sceptic, far from it. I've been immersed in AI coding for more than eighteen months, well before it was (really) any good, and the game changed for me like everyone else when Sonnet 4.5 landed last September and you could suddenly build real things without holding its hand at every step.

The pay-off of AI coding is real, and it is enormous. I am building things in single-digit days that would previously have taken me months (that's not an exagerration). I'm building whole categories of work that I'd only ever dreamed about and never had a chance to attempt, because the (time and effort) cost of trying was simply too high. When I'm the subject matter expert and the feedback loop is tight, the gap between an idea and a working version of it has gone from a quarter to a long weekend.

That's not hype. That's the thing that keeps me at the machine. The dopamine hit when an agent comes back having built something genuinely good, (relatively) fast, is powerful. It should be. It's the most exciting shift in how I build software that I've experienced in twenty years.

I'm using AI to not just write the code either. I'm using it across nearly the whole lifecycle: drafting the plan, having it question me and surface the things I should be aware of before I commit to an approach. Writing the architecture decision records and the architecture diagrams. Writing the code and the tests. Reviewing the code. Running smoke tests. Building out the infrastructure as code. Writing the commits, raising the pull requests and describing them, then following through when the build fails. Patching vulnerable packages. Debugging failed deployments by reading the telemetry. I'm using AI for almost every part of the software development loop.

None of this is hands-off. All of it is scaffolded, with guardrails, with my own taste and judgement sitting over the top, and a mix of deterministic and non-deterministic checks to catch what I'd otherwise miss. The AI does the grunt work. The direction, and the standard, are still mine.

As a business leader with broad responsibilities, until recently I only found rare opportunities to write software. The time simply wasn't there, and so a lot of the building I wanted to do never happened. With properly autonomous AI coding, that's changed. With the right direction up front, the AI can be coding while I get on with the rest of my job, and I check in at the points that matter. The work progresses while my attention is elsewhere.

I know plenty of other founders and execs with engineering backgrounds who are doing exactly the same thing. It's a pattern I've started to notice: these people are combining their business knowledge, their software expertise, and AI to do the grunt work they no longer have the hours for.

The dopamine hit I mentioned, the one when the AI produces something impressive in minutes, is the easy part. What comes after it is brutal. Getting that impressive first version actually right, actually ready to ship, takes an enormous amount of effort and attention to detail. And that's where the hours disappear. You sit there refining, correcting, waiting for another run, watching it get close and then watching it do something baffling, pulling that slot machine lever again, and again...

That's the AI slot machine. In macro terms it's fast, faster than anything I've worked with. But in the micro, moment to moment, it's slow, and it keeps you sitting there, late at night, long after the rest of the day's work is done, telling yourself the next pull will be the one that lands it.

The obvious move is to run several agents at once, three, four, five tasks in parallel, so you're never just sitting watching one of them think. And it works, up to a point. But flipping between that many threads has a real cost. Holding the context of five different problems in your head at the same time, then dropping back into each one and switch back to where it was up to, is exhausting. The waiting goes down, but the cognitive load goes straight up. You've traded one kind of drain for another.

Lately I've been trying to work out why I keep ending up here, coding late into the night when I don't have to, so I can do something about it. I haven't landed on a clean answer. Part of it is that the work is genuinely absorbing in a way it hasn't been for years. Part of it is that the next good result always feels like it's one run away. Whatever the mix, the honest position is that I haven't got it under control yet, and I'm wondering whether it's just me or not. If it's not just me, then I think it's worth talking about publicly, openly, so we can collectively work out techniques to address it.

This is all relatively new. Using AI with this much autonomy has really only been possible for the last six to eight months. I doubt many people have it properly figured out yet, whatever the hype suggests. AI coding is amazing and maddening, often in the same minute. If you're building this way too, I'd like to know whether your nights look anything like mine and what techniques you have to manage the draw of the AI slot machine.