Accept Nothing

This website is the case study. It was built in a 48-hour window using Claude Code, then deployed globally through GitHub Pages and Cloudflare, and we didn't write a line of the code by hand. The stack is nothing but the fundamentals: HTML, CSS, JavaScript and JSON-LD for search and AI discovery. None of that tells you much about how it actually got made though.

There's a belief going round that AI replaces expertise with a single prompt: press a button, get a finished product. It doesn't work like that. With AI there's no such thing as a wrong question, but there are lazy ones, and knowing which one you're actually asking is harder than it sounds, because AI will answer either kind with the same confidence.

What was human and what wasn't

Claude did the typing, in effect: execution speed, syntax, refactoring in the terminal. The bigger calls, architecture, performance constraints, what the site actually looks like, were ours to make, and the final say on all three sat with me. I created the visual identity, picked the typefaces, chose the colours, made all the graphics and directed every page of content, and Claude helped pull it together fast. This isn't a story about pressing a button and a website falling out the other end.

Along the way, the same process gave us something we hadn't planned for: a workflow for publishing new Journal articles. It flags which other channels a piece needs adapting for, where it fits best by topic, the basics on SEO and AI discovery and the length constraints that keep things scannable, all as markdown files that slot straight into the iA Writer setup we already write in.

Beyond the default AI look

The first pass was fast and looked like every other AI-generated site: functional, generic and bloated by the second or third round of changes. Prompt engineering only gets you so far. Design expertise has to take over from there, pushing past the AI's default assumptions instead of accepting its first answer.

We see effort being eroded a lot as AI does more for us, and that's a mistake. Left alone, AI will pull in heavy font packages, inject redundant inline styles and duplicate structure across pages. It'll look good right up until you actually dig into what's underneath it. Spotting those patterns and pushing back took human judgement, not a better prompt.

We iterated through three full design layouts before settling on one, working through type and spacing first rather than grids and columns. Over the hours, Claude was a near-perfect assistant. Plenty of things a human eye still catches faster than an agent. Plenty of things the agent did faster and better than a human.

Refactoring through technical dialogue

The clearest example came from a two-hour audit, where we treated Claude Code like a developer and asked it to review its own work instead of accepting the first pass as finished.

• Styling: we audited the CSS for duplication and extraneous rules, and made Claude justify every external font against the new design system. Result: a 43% reduction in CSS overhead.
• HTML hygiene: we eliminated inline styles and pushed every script into a dedicated external file. Result: an 11% reduction in HTML file size and faster load times.
• JavaScript efficiency: before configuring caching, we had Claude analyse JS usage across the site and cut the duplication it found.
• Asset optimisation: raster logos became scalable SVGs, cutting network payload while keeping everything crisp. Swapping remaining JPGs for WebP is next, and it'll be the biggest saving yet.

None of it would have happened without someone insisting the first output wasn't the finished thing.

A career with heavy digital exposure gave us the GitHub account this runs on, and GitHub Pages makes hosting a static site free, served over HTTPS. That got us most of the way, until search engines needed proper 301 redirects for anything permanently moved, which GitHub Pages can't do cleanly on its own. Cloudflare filled the gap, on a free account, with redirects plus a full toolbox of security, analytics and speed tools thrown in. It's a large enough piece of internet infrastructure, serving something in the region of 20% of all internet traffic, that upgrading later won't mean rebuilding anything.

Deployment to GitHub Pages and Cloudflare took minutes. Getting Cloudflare properly configured took an hour. What came out the other end was fast and lean.

Is it a perfect example of website engineering? No. Is it better than either of us could have produced alone? Yes.

The big win

Every prompt, audit rule and constraint we settled on during the build got written down into a rules file Claude reads at the start of every session, on this project and the next. It's the same idea as the article workflow mentioned earlier, just applied to the build: write the standard down once, and updates to the site or the Journal keep holding to it without us re-explaining it every time.

The real win isn't speed. It's that the standards live in the project now instead of in our heads, so they can't be forgotten or ignored.

The expertise and speed handshake

Judgement is what makes the speed useful. On its own, speed just gets you to the wrong answer faster. Claude handled syntax, refactored across files and audited logic in seconds. Twenty years of design experience is what stopped us shipping whatever the AI would have settled for on its own.

The secret here is to accept nothing. Test and challenge everything. Just like you always have. You can just get it to a higher standard more quickly now. And there's nothing to not like about that.