Rebuilding My Site with an AI Agent: A Field Report

This site you are reading is the second version of itself. The first was a dense, CV-style personal page. It was accurate but tired, a wall of roles and dates that read like a printed résumé pasted into a browser. I wanted something closer to a modern portfolio: a dark theme, a working blog, a bit of craft to it. The reason I am writing it up is how I rebuilt it. I did not hand-code the new version. I directed an agentic coding tool, Claude Code, to do the building, while I did the deciding.

This is a field report on that experience: what genuinely worked, what still needed a human in the chair, and the one line I refused to let the tool cross. I am writing it in the first person because it is my own recent project, and because the honest bits only land if I own them. It is not a sales pitch. The tool is good. It is also not magic, and pretending otherwise would undercut the only useful thing a report like this can offer.

What the workflow actually looked like

I started with the mental model "describe the whole site, get the whole site back". It was wrong, and usefully so. The real process was iterative and conversational, far closer to art-directing than to issuing a spec. I set a direction, looked at what came back, reacted, and refined in passes. The interesting work lived in the reactions.

The direction I opened with was deliberately loose: a premium dark theme, with a light/dark toggle so it did not assume everyone wants dark mode. From there the project moved in distinct refinement passes, each one a small conversation:

• Dropped in a real photograph instead of a placeholder, and adjusted the layout around it.
• Changed the accent colour, then reshaped the logo and the buttons until they felt of a piece.
• Rewrote the experience section and, importantly, removed the company names so it read as impact-led rather than as a list of employers.
• Built a blog: not a stub, but real, readable post pages with proper typography.
• Then went further and produced two multi-part technical series to give the blog something to actually hold.

None of those were in the original brief. Each emerged from looking at the previous state and deciding what was wrong with it. The loop, stripped to its bones, looked like this:

        +-----------+        +-----------+        +-----------+
        |  DIRECT   | -----> |  REVIEW   | -----> |  VERIFY   |
        | (human)   |        | (human)   |        | (agent)   |
        +-----------+        +-----------+        +-----------+
              ^                                         |
              |                                         |
              +--------------- refine ------------------+

  DIRECT : set intent, taste, constraints, the next small change
  REVIEW : read the diff, judge the result, decide what is wrong
  VERIFY : build it, open it, screenshot it, check it really works

The thing that surprised me was how much of my time moved to the left-hand box. I was not typing CSS; I was deciding whether a spacing felt right, whether an accent colour read as confident or garish, whether a sentence was honest. The typing had been outsourced. The judgement had not.

What worked well

Three things stood out as genuine force-multipliers.

Scaffolding and refactoring speed. Standing up the structure of a page, then restructuring it when I changed my mind, happened in minutes rather than the afternoon it would have cost me by hand. The cost of changing direction dropped close enough to zero that I changed direction more often, which for design work is a good thing. When iteration is cheap you can afford to reject more, and the end result is better for it.

Content generation and layout. Laying out sections, generating consistent markup across many similar pages, keeping a blog index in step with its posts: this is the kind of repetitive, structured work where the speed-up is real and the error rate, with review, is low.

Long-form drafting in parallel. The technical series were drafted with parallel sub-agents working on different articles at once. As a way to get from blank page to a full structured draft quickly, it was effective. I want to be careful here, though, because this is also where the trouble started. A fast draft is not the same as a publishable one.

Verification, which I did not expect to matter as much as it did. The single feature that most changed how I trusted the output was that the agent could drive a headless browser: open a page it had just built, take a screenshot, check the links resolved, and read the browser console for errors. Changes were observed working rather than assumed working. That is a meaningful difference. A sketch of that step:

# After a change, don't trust it — look at it.
launch headless browser
  open  posts/case-study-rebuilding-site.html
  wait  for network idle
  shot  → screenshots/case-study.png      # eyeball the layout
  check console.errors  == 0               # no broken scripts
  check broken_links([a.href])  == []      # nothing dangles
report PASS/FAIL back into the loop

That closing of the loop is what separates "the model claims it fixed it" from "the page renders, the links work, the console is clean." It does not catch everything (a screenshot will not tell you a sentence is dishonest), but for mechanical correctness it removes a whole category of silent breakage.

What needed human judgement

Two things never left my hands, and they are the credible core of this report.

The first is design taste and direction. Every meaningful aesthetic call was mine: the accent colour, the shape language of the buttons, the decision to strip company names in favour of impact. The tool would happily produce a competent default in any direction I pointed it. It would not tell me which direction was right, and on the occasions I asked it to "just make it look good," the result was generic. Taste is a judgement about intent, and intent is not something I could delegate.

The second is harder, and more important. It is authenticity, and it is where I had to push back hardest.

When the agent first drafted the technical articles, it wrote them in a confident first person, full of vivid "war stories." Incidents I had supposedly debugged at 3 a.m. Lessons supposedly learned the hard way on systems I had supposedly run. They were well written and completely fabricated. I had not lived a single one of them. Read in isolation, each anecdote was plausible; read by me, they were fiction with my name on the byline.

An agent will, by default, write in your voice about experiences you never had. The prose is convincing precisely because it is invented to be. Publishing fabricated personal experience under your own name is not a style choice. It is a lie, and it was the one line I would not let the tool cross.

So I had the articles rewritten into a neutral, general voice: explaining how things work, not pretending I had personally fought every fire. Where a technical claim remained, I insisted on checking it rather than trusting the confident phrasing around it. A draft that sounds authoritative is not the same as one that is correct, and the agent is equally fluent in both. Fluency is not accuracy, and confidence is not honesty. The byline carries my accountability whether or not I did the typing, and that does not transfer to a tool.

The balanced takeaway

I came away convinced that agentic tooling is a genuine force-multiplier for work like this. The site is better than the one I would have built by hand in the same time, because the cheapness of iteration let me make more decisions and reject more bad ones. That is real, and I would not want to undersell it.

But the effort did not disappear; it moved. It shifted from typing to directing, reviewing, and verifying. The bottleneck is no longer how fast I can produce markup; now it is how clearly I can express intent, how carefully I read what comes back, and how honest I am willing to be about what is true. Those are not smaller jobs. In some ways they are harder, because they are the parts that cannot be automated away without automating away the point.

So the report nets out like this. The agent accelerates production, and meaningfully so. It does not own the intent, the taste, the truth, or the accountability. Those stay with the human, and the authenticity problem is the sharpest reminder of why. If you take one practical thing from this, let it be the discipline of the loop: direct, review, verify. The tool is happy to skip the middle two. Do not let it. What goes out under your name is still yours.