Idea, Design, Build, Ship

Setting up an end-to-end AI build process

Building Poo Head taught me something I didn't expect: the fun wasn't the game, it was the process. So after shipping it I stopped treating each project as a one-off and set up a proper end-to-end pipeline — idea to live site — where an AI does the work at every stage and I direct.

Here's the assembly line I landed on.

Four stages, one director

The process has four stops: shape the idea, design the look and feel, build it, ship it. What ties them together is that I never really touch the tools directly. I describe what I want, an AI does it, I check the result, and I send it back with corrections. My job is taste and judgement, not typing.

The trick I've learned is to keep the stages separate. Ask for design and code in the same breath and you get something that works but looks like every other default. Splitting them means each stage gets a clean, specific brief — and each one becomes a place where I can stop and say no, not like that.

Design first, with Claude Design

This is the stage I used to skip, and it's the one that changed the output most.

Instead of jumping straight to code and accepting whatever grey, templated UI falls out, I now settle the look and feel first — on a canvas, in Claude Design. I describe the mood I'm after — for the card game, green felt, brass edges, a slightly cheeky casino feel — it lays out real visuals, and I iterate by chat until the colour, type and layout actually feel like mine rather than a framework's defaults.

Nail the art direction before you pour the concrete. It's far cheaper to change your mind on a canvas than in a codebase.

Only once the visual direction is locked does it become the brief for the build. The AI writing the code isn't guessing at style any more — it's implementing a look I've already signed off.

Wiring it to the real thing

The last piece is connecting all this to my actual site. chappers.xyz runs on Next.js and Supabase, deployed through Vercel, so the code has to land in a real repository, not a sandbox.

So I point the AI at my GitHub repo and let it work with the real codebase in context — the actual files, the actual structure — rather than inventing something that won't fit. Changes go in, Vercel builds and deploys them, and the thing is live. I can even kick a lot of this off from my phone, which still feels faintly absurd.

What actually changed

None of these stages is new on its own. What's new is chaining them into one directed flow: an idea becomes a look, a look becomes working code, working code becomes a live site — and I'm steering at every handover instead of doing the labour at any of them.

The work that's left for me is the work that matters: deciding what good looks like, writing a clear brief, and testing the result like a sceptic. The AI is astonishingly fast at everything between those points. It's just never the one who decides whether the thing is actually any good.

That's still me. I suspect it'll stay that way.