I built this site the way I build products

The agent wrote the code. I defined what the site had to accomplish, what it was not allowed to compromise, and what had to be checked before it could ship.

• 16Static pages
• 0Client-side scripts on content pages
• 22 / 22Colour pairs passing
• 10Old essay URLs preserved

The brief came before the build

I wrote the standard before touching the design, so disagreements resolved against it rather than against taste — and while changing course was still cheap.

Every requirement names its verifier. Most are enforced by a script that fails the build. The rest are read by a person, and the page says which is which.

• A hiring manager can place me in the first minute

  Time constrained, highly trained, hard to impress.

• Every important claim has evidence

  A working product, a component library, a design artifact, or a visible result should sit close to the claim it supports.

• Leadership reads as capability

  The site should show how I establish direction, improve decisions, and raise the quality of other people’s work — not simply state the title I have held.

• The site demonstrates the practice it describes

  I claim that I direct AI agents to produce production code. The portfolio should provide evidence of that practice in its own construction.

What changed

I read the previous site end to end first: nine essays, three project cards, a summary, three references.

The leadership argument was clear. The evidence was not. Most of it ended in a deck, and almost nothing could be opened.

Product work comes first because it establishes what I can make. The essays explain how I lead the people and systems around it.

Directing the agent

The agent wrote the implementation. I set the objective, the boundaries, the design system, the review criteria, and the actions that needed approval.

I read every consequential change, and rejected plausible work that weakened the argument, introduced an unsupported fact, or cost more than it returned.

Code made those decisions cheap to test. A background change is one token. A typography change took an unused font out of the whole build. Every change is checked against the same system before it ships.

Generation made options cheaper. It did not make judgment optional.

The quality gates

Some things a machine can check. Some it cannot. The build draws that line.

The first gate matters most. The site argues that every claim can be opened, so a dead deployment fails the build the same way a broken link does.

• Every deployment and design file the site points at still answers.

  AUTOMATICnpm run evidence · every external artifact in the built output

• Every colour pair meets WCAG AA at the smallest size where it appears.

  AUTOMATICnpm run contrast · 22 pairs computed from the design tokens

• No unfinished slot or unapproved line ships unnoticed.

  AUTOMATICnpm run needs · derived from the built HTML

• Every URL preserved from the previous portfolio still resolves.

  AUTOMATICnpm run links · every URL preserved from the previous site

• No internal link returns a 404 or points to a missing anchor.

  AUTOMATICnpm run links · every internal href in the built output

• Content pages ship without client-side JavaScript.

  AUTOMATICVerified from the static build output

• Every image has alt text, and no two images share it.

  AUTOMATICnpm run alt · the second rule is what catches a description copied from the image above it

• Every page has one H1 and a logical heading sequence.

  HUMAN REVIEWHeading structure is reviewed page by page

• The first line of every page lands in the same place.

  HUMAN REVIEWAlignment is checked across routes and breakpoints

Scripts hold the rules that can be stated exactly. People hold meaning, hierarchy, and whether the argument lands.

Contrast is computed, not assumed

Every pairing is checked at the smallest size it appears. It failed twice during the redesign. Both times the token changed rather than the component, so the fix propagated everywhere.

22 of 22 documented colour pairs pass.

What the result proves

The point is not that an agent can build a portfolio. It is that a clear operating system turns fast generation into work someone will sign.

The site is static, accessible and inspectable. The code is public, the claims connect to running work, and the checks encode standards that outlast whoever set them.

That is the problem I work on elsewhere: make intent explicit enough that people — and now agents — can act on it without lowering the standard.