I built this site with an AI coding agent

The site you're reading was built largely with an AI coding agent. The project pages, the interactive demos, the little games arcade, and this very blog — most of it was drafted, refactored and iterated with an agent sitting beside me. This post is the honest version of how that actually went: what the collaboration looked like, what worked, and what I still had to own.

I write a lot on this blog about AI as leverage on top of judgement. It felt dishonest to make that argument without showing my own work — so here it is, the meta-post. No mystique, no "I just typed a prompt and a website appeared." Building this was a real collaboration with a clear division of labour, and the interesting part is exactly where that line sits.

The stack is deliberately boring

There's no framework here, no build step to speak of, no server. It's hand-written HTML, CSS and a little vanilla JavaScript, with the content-heavy pages driven by small JSON data files. Everything is committed to a Git repository and deployed straight to GitHub Pages, served at a custom domain. That's the whole architecture.

Boring is a feature. A simple static stack means there's nothing to misbehave at runtime, every page is just a file I can read end to end, and the AI agent and I are always looking at the same plain text. When the surface area is small, review is fast — and review is where the real work lives.

The build loop. The agent makes the cheap part cheaper; the review step is mine and non-negotiable.

What the collaboration actually looked like

The easiest way to describe it is a pairing in which the roles are sharply split. I set the direction and made every decision that mattered; the agent did the fast, repetitive, mechanical work of turning intent into working code. Concretely:

I described the intent. "A blog index that reads from a JSON file," "a demo that feels like a real internal portal," "make the project cards consistent with the design system." Goals, constraints and taste — not implementation.
The agent drafted. It wrote the markup, the CSS, the small scripts, and wired pages to their data — usually faster than I'd have typed the boilerplate myself, and consistently in the house style once the system was set.
I reviewed and tested everything. I read every diff, opened the page, clicked through it, checked it on mobile, and pushed back on anything that was off — wrong, ugly, or subtly untrue.
We iterated tightly. Most things took a few rounds. Because a static page is cheap to regenerate, trying a second or third approach cost minutes, not hours.
Then I committed and deployed. A commit to the main branch, GitHub Pages rebuilds, and the change is live at the custom domain. No pipeline to babysit.

That loop is the whole story. It's not "AI builds a website." It's me using an agent to compress the distance between an idea and a working, reviewed version of it.

What genuinely worked

The honest wins were mostly about momentum. Speed, yes — but more importantly the ability to try ideas cheaply. When trying a layout or a demo costs ten minutes instead of an afternoon, you try more of them, and you keep the good ones. A lot of what's on this site exists simply because the cost of experimenting dropped low enough that I bothered.

The other quiet win was consistency. Once I'd settled a design system — the spacing, the colours, the components in blog.css, the navigation — the agent applied it uniformly across dozens of pages without drifting. That kind of disciplined repetition is exactly what humans get bored doing and machines do not.

The agent didn't give me taste, accuracy or judgement. It gave me speed on everything downstream of those — which is most of the typing.

What I had to own

This is the part that matters most, and the part it would be easy to gloss over. The agent is fast and tireless, but it has no stake in whether the result is good or true. That was entirely on me.

Taste stayed mine: whether a page felt right, whether a demo was clear, whether the writing sounded like me and not like generic web copy. Accuracy stayed mine: every claim on this site about what I've built or what I do had to be something I'd stand behind. And the line between true and merely impressive was a line only I could police — an agent will happily make something sound more accomplished than it is if you let it.

The guardrail that mattered most Review everything, keep it honest, and never let the tool inflate a claim. Fast drafting is only an asset if a person who actually knows the truth is checking every line before it ships. The agent writes; I'm accountable for what stays.

There's a concrete example of that discipline elsewhere on the site. The internal-portal demo is built entirely on synthetic data — no real company names, brands or numbers — precisely because the point is to show the shape of a product without borrowing credibility I haven't earned. The agent could have made it look more "real." It shouldn't, and didn't.

The honest verdict

An AI coding agent turned out to be a genuinely good pair-builder for a project like this: a lot of surface area, a clear design system, low stakes per change, and a human who knows what "done" looks like. It made me faster and bolder. It did not make me redundant — if anything it raised the value of the things only I could supply: direction, taste, and the willingness to say "that's not quite true, do it again."

Which is the same thing I keep landing on across this whole blog. AI is leverage, and leverage multiplies whatever you point it at. Point it at good judgement and honest standards and you ship more, faster. Skip those and you just produce polished mistakes at speed. This site is my small, working proof of the first version — built in the open, reviewed line by line, and kept honest on purpose.