How I Built My Personal Site with AI Agents

This site is a static Astro build on Cloudflare: a home page, About with my CV, and this blog. AI agents wrote almost all of its code, Claude Code most of it and OpenAI’s ChatGPT app alongside, and I decided what went in. The numbers below come from the git history, since most of the chat sessions are gone.

What the commit count leaves out

I built the site twice. The first version took three days in April. The second, the one you are reading, took eight days in October: 156 commits, 101 of them in the first two days, live on the second day. Across both builds that is 214 commits on 12 working days. Every page scores 100 in Lighthouse on mobile and desktop, passes an axe accessibility check and works without JavaScript.

The first build was fast too, and I replaced it. This time I wanted a site I would keep working on after it went live.

Two builds, six months apart

The April version was what a coding agent makes when you ask for a personal site: a dark home page with a WebGL shader behind it, a blog with search, pagination and twelve made-up posts, DaisyUI components and hosting on Vercel. It took three days and looked like many other developer sites. In July I moved it to Cloudflare in one evening, and then I stopped opening it.

In October I started over with a different idea: the site as a technical drawing, graphite on tracing paper in the light theme and a cyanotype in the dark one. The shader, the search, the component library and the mock posts all went.

The technical drawing gave me something to judge each addition against. A timeline could use dimension lines; a chart could share the same strokes. In April, I had usually moved on once the page worked. Now I also checked whether it fit the drawing.

How I worked with the agents

The same loop worked for the whole site and for a single detail: look at what exists, get several options, pick one, have it built, run the checks. Then the next detail.

The design never started in the repository. I explored it in claude.ai as plain HTML pages: a moodboard with the rules, a study of the navigation, a study of the background at different widths, then the home page at five widths and the inner pages in both themes. They were cheap to make and cheap to throw away, so I asked for far more options than I would ever ask a designer for. Once I had picked one, the repository got a written spec: the values and the behavior to rebuild, with the prototype’s code left behind.

I found it easier to reject a prototype when it was still a separate HTML page. I could decide whether I liked it before working out how it would fit the site’s components.

I ran the work in parallel. Usually one session built while another researched or tried a variant of a drawing. Near the end I had four agents audit the site at once, each with one skill: design, classic SEO, AI search and prose. They came back with 19 fixes, and I took them in three batches.

I enjoyed comparing versions and tuning the one I liked, sometimes a pixel at a time. The Experience timeline on About went through three versions in two hours: names on spans, then dots with a dashed end, then ticks with the project’s span drawn as a dimension line on hover. The pencil strokes that drift over the home page drawing took three rounds in about an hour.

I used to cut this kind of polish from side projects because each round cost an evening. With agents, I could spend a few minutes on another version and compare it on screen before deciding whether to keep going.

Claude Code and ChatGPT, side by side

I used two agents at the same time: Claude Code from Anthropic and OpenAI’s ChatGPT desktop app with Codex. They overlap on most tasks, and each still ended up with its own job. This is how they worked for me on this site; I would not use it as a ranking for every kind of project.

Claude Code understood me with less explaining. A short request, often in Russian, was usually enough, where the other agent needed more context spelled out. It was also better at the technical work: the geometry of the drawings, the Lighthouse fixes, the structured data. Most of the code in the repository came from it.

The ChatGPT app was the better place to work with agents. It is an ADE, an agentic development environment: an app built around agents running tasks, where an IDE is built around files and a terminal around commands. Keeping several tasks in view, coming back to one later and following what an agent was doing all felt easier there than in a terminal.

So the split settled by itself: the ChatGPT app as the workspace for research and side questions, Claude Code for anything that ended up in the repository. The project’s skills are shared between both agents, so either of them starts with the same rules.

Where it went wrong

45 of the 214 commits start with “fix”. Most of them are layout fixes, such as centering, spacing and labels running into each other at one width, and any site has those. Five other problems came back again and again, and they are the ones worth knowing before you try this.

Copy that sounds machine-written

The agents’ drafts of About read like every AI-written bio: “not X but Y” contrasts, three slogans in a row, the same phrase twice. I rewrote the copy in at least four rounds, and a separate review with a prose skill still found tells after the last one. Text took more of my own time than anything else, and it is where I trust agents least. A layout problem is usually visible at the width where it breaks. A sentence can be grammatical, accurate and still sound like something I would never say. I had to read for that myself.

Numbers nobody confirmed

To fill the layout, an agent put example figures on About. The site went live with them, and I kept About and the CV away from search engines for a week until the real numbers were in. I had accepted a page that looked finished without confirming its figures. Since then the project has a rule: a fact on the site needs my confirmation.

Rules forgotten between sessions

I asked twice to be answered in Russian. Commits came with an AI co-author line after I had said not to add one, and I rewrote the history twice to remove it. I had expected those corrections to carry over to the next session. They did not, so I needed to save them somewhere the next agent would read.

Docs drifting from the code

The two most-edited files in the repository are not code. The redesign plan changed in 85 commits and the design spec in 60, more than any page. The agents kept them in sync only when asked, and an audit still found the spec and the agent instructions contradicting each other. In the end I merged them into five short topic docs and deleted the plan. Every extra description of the same behavior was another place that could disagree with the code. Shorter docs gave me less to keep synchronized and made contradictions easier to find.

Building more than needed

A component library, a Lighthouse CI tool, a page that showed off the drawing kit, an italic font, and the blog itself three times: all added, then removed. Agents add things readily. Removing them took about ten cleanup commits, and every time I was the one who asked. Cheap implementation made it easy to accept an addition before asking whether I wanted to maintain it.

I make the same scope decisions when estimating a software project: something can be useful and still belong outside the current version. On my own site, I had to be the person making that cut.

What kept it on track

Checks the agent cannot argue with

npm run check runs Prettier, the unit tests, the build, a script that checks every page’s title, description and structured data, and an axe accessibility check. Nothing is committed until it passes. npm run check:full adds Lighthouse on mobile and desktop and expects 100 in every category. Those checks gave the agent a result it could work toward without asking me to inspect every detail. They also let me spend more of my review time on the things they could not measure, such as whether a drawing fit or the copy sounded like me.

The checks also caught things I would not have looked for. Cloudflare’s automatic analytics injection cost the mobile score 2 points, so the analytics script now loads a second after the page does. Preloading both font faces scored better than preloading one.

Rules that grow from corrections

Every correction I had to make twice became a line in AGENTS.md, the file every agent reads first. It says that I decide, that files are in English, that npm run check passes before a commit, that there is no email address on the site, that every page works without JavaScript at Lighthouse 100, and that values come from the design tokens. How I like to work, such as pushing and deploying only when I ask, went into the agent’s memory. A new session now has those decisions available before it starts work. I still have to check that it follows them, but I no longer depend on the previous conversation being remembered.

One skill per concern

Skills are packaged instructions an agent loads for a kind of task. I started with eight design skills. Two conflicted and were gone within a minute, and five more went a few days later. Now there is one per concern: design, SEO, AI search, prose, the content plan and positioning. They are pinned in the repository and shared between Claude Code and Codex, so I no longer set up the same rules in every project.

The setup I ended up with

What I would do again

I would keep the prototypes outside the repository and use the agents in parallel. Seeing alternatives made my decisions better, and having one session research while another built kept that work moving. I would also put the rules and checks in place earlier, before a second session had a chance to repeat the first one’s mistakes.

I would spend more time reviewing additions before accepting them. I removed the April design and several dependencies later; the example numbers should never have reached the live site.

The timeline and the pencil strokes are details I would once have dropped. I enjoyed working on them, and I want to leave room for that on the next project too.