This Blog Was a Weekend Idea

An idea over coffee on a Saturday; a production monorepo twenty-four days later. This blog — the one you're reading — was built mostly by AI agents, something like 1,250 commits of them, with me steering. This is the map of how that happened, and every turn has its own post. The short version: the speed didn't come from agents typing fast. It came from handing them sharp targets and boundaries they couldn't wander out of.

The whole build in one breath

Coffee to running skeleton took an afternoon: a one-page spec, one scaffold command, a typed Turborepo. From there the work split across scoped agents, each fenced into a single layer of the stack — the trick I lean on hardest, written up in Layer Contracts. Twenty-four days later it was a statically rendered Next.js site backed by Sanity, and the honest surprise is that I'd merge almost any of those commits again.

What actually made it fast

Three habits did the heavy lifting, and none of them are prompt tricks. I wrote the spec before the scaffold, so "done" was never ambiguous. I kept the house rules in a CLAUDE.md the agents re-read before every task. And I made correctness checkable — a typed data layer and a CI gate — so a bad change failed loudly instead of shipping quietly.

An agent optimizes for the task you gave it, not the task you meant. The whole build was an exercise in closing that gap cheaply.

One source of truth per concern

The spine of the design is boring on purpose: every layer has exactly one place the truth lives, and everything downstream derives from it. The schema owns the content shapes, the service package owns every query, and the app just consumes typed functions.

1blog/
2  apps/cms          # Sanity Studio — the schema is the source of truth
3  apps/web          # Next.js 16 — statically rendered, instantly fresh
4  packages/service  # the only place a query lives, typed end to end

That layout isn't decoration; it's what let agents work in parallel without colliding, because each one had an obvious and only place to make its change.

Read the series in order

Each post is short and stands alone, but they tell one story front to back:

• From Idea to Monorepo in an Afternoon — spec first, then one scaffold command.
• Layer Contracts — scoping each agent to a single typed layer.
• CLAUDE.md Is the Steering Wheel — the rules every agent re-reads.
• Designing the Content Model by Conversation — arguing the schema into shape.
• A Typed Service Layer with groqd — queries the compiler can vouch for.
• Rendering Portable Text in Next.js 16 — turning block JSON into an article.
• Styling at Speed: Tailwind v4 With an Agent — design tokens as guardrails.
• Shipping Heroes Without a Designer — hero art from a pipeline, then by hand.
• SEO That Generates Itself — metadata derived, never maintained.
• Statically Rendered, Instantly Fresh — static pages that update on publish.
• 24 Days, ~1,250 Commits — the honest retro on what the agents got right and wrong.

A weekend idea scaled into a build because the constraints were written down first. The agents supplied the speed; the boundaries are the only reason the speed was worth keeping. Start with the first afternoon and follow the thread from there.