Fun bit of history: most of this website was originally thrown together with ChatGPT 3.5 back in the day. The whole thing is a single PowerShell script that reads some markdown files and spits out HTML. No frameworks, no node_modules folder the size of a small moon, just a script. And honestly, 3.5 did alright for its time. The site existed, it mostly worked, and the build ran in about two minutes on our git runner instead of twenty.
It also had some absolute classics in there. The blog page literally could not scroll (a stray overflow hidden on the body), the contact section rendered as a single "#" character, and bullet lists showed up as one giant run-on paragraph. There was a bullet point character that displayed as "•" because of an encoding mixup. My favorite one was the "#" bug, which turned out to be a genuinely cursed PowerShell quirk: when you split a string and pipe it, a single element array gets unwrapped into a plain string, so indexing [0] gives you the first character instead of the first section. That one had been sitting there for over a year.
So recently I pointed Claude Code at the repo, running the new Fable model, and basically said "read this project and fix it". What happened next was interesting enough that I figured it deserved a post.
The thing that stood out wasn't that it wrote better code (although it did). It's that it worked like a stubborn engineer instead of an autocomplete. Before touching anything it ran the build, reproduced every bug, and confirmed the root cause. For the rendering issues it spun up a headless browser, took actual screenshots of the pages, and looked at them. At one point it "found" a mobile layout bug, dug deeper, and figured out the bug was actually an artifact of how the headless browser takes screenshots at narrow widths. The site was fine. Old me would have "fixed" that non-bug and broken something real in the process.
The part I really wanted to write about is the agent stuff, because this is where things get a bit sci-fi. After doing the refactor, Claude Code fanned out a couple dozen sub agents to review its own work. Four reviewers, each with a different specialty: one just for PowerShell correctness, one for the markdown converter, one for CSS and layout, one for accessibility and the CI pipeline. Every bug a reviewer claimed then got handed to a separate skeptic agent whose only job was to try to disprove it by reading the code and actually running it.
Out of 21 claimed bugs, 17 survived that gauntlet and 4 got thrown out as false alarms. The survivors were real finds too. The markdown converter could be tricked into emitting broken HTML. A heading like "C#" would render as just "C" because the regex ate the trailing hash. The scroll snapping was double-offsetting every anchor jump by exactly one header height because two CSS properties were quietly stacking. None of that came up in the first pass. It came from the swarm arguing with itself.
Structurally the site got a proper glow up while keeping the original philosophy, which is: markdown stays intentionally dumb, PowerShell does the work, and the build stays fast. The converter is still hand rolled in pure PowerShell (no libraries, that's the whole point), it just actually handles lists, headings, links and escaping properly now. Each blog post gets its own page instead of one endless scroll. The blog index shows excerpts with read more links. There's a real sitemap.xml generated at build time, and deploys went from a per-file scp loop to a single rsync, so publishing takes seconds.
Credit where it's due: ChatGPT 3.5 got this thing off the ground when "AI wrote my website" was still a party trick. But the difference a couple of model generations makes is wild. It's not the prose or even the code quality. It's that the new one can run your project, look at the output with its own eyes, send a small army of clones to tear its work apart, and only then call it done. That post about AI tools we wrote back in 2024 said the tools would keep transforming how we build. Didn't expect the tools to come back and fix that exact website though.
If you've got one of these projects yourself, an old repo that mostly works except where it doesn't, here's the recipe as a prompt you can hand to whatever agent you use. Nothing in it is specific to our site. Steal freely.
Read and understand this project completely before you change anything: the code, the build, the history, and whatever it produces. Then refactor it so it actually works, under these rules:
- Reproduce before you fix. Run the project and confirm every suspected bug with real output before writing a fix. Root causes only, no guessing from reading the code.
- Look at what it actually produces. If there's a UI, render it and inspect screenshots. If it generates files, open them and check the bytes. Code that looks right is not evidence.
- Respect the original philosophy. Work out why the project was built the way it was (simplicity, speed, no dependencies, one language, whatever) and improve it within those constraints. Do not swap in your favourite stack.
- Review your own work adversarially. When the refactor is done, examine it from several independent angles: correctness, edge cases, output quality, security, and how it fits the build and deploy pipeline. For every bug you believe you found, actively try to disprove it before accepting it. Only fix what survives.
- Prove each fix with the exact input that used to fail. If you add a safety check, break something on purpose and confirm the check catches it. A validator that has never failed is untested.
- Leave guardrails behind. Add cheap permanent checks (a build-failing validation step, loud warnings where failures used to be silent) so the class of bug you just fixed cannot quietly ship again.
- Report honestly. What was broken, what you fixed, how you verified it, and what you deliberately left alone and why. If something failed, say so.
That last one matters more than it looks. An agent that can tell you what it didn't do is one you can actually trust.