How I Build

I define what should be built, and the agent figures out how.

This isn't vibe coding or blind token burning. The human stays in the loop — I make every decision, the agent writes every line of code.

The documents

The workflow runs on a handful of documents. A .building/ folder holds the entire system. The agent reads relevant documents at the start of every session.

.building/
  product.md      — what it is, why it exists
  design.md       — layout, typography, colors
  iterations.md   — which iteration is active
  <iteration>/
    spec.md       — objective, constraints, non-goals
    plan.md       — slices with exit criteria
    changelog.md  — what changed in each task

In each iteration, spec.md is where I draw the boundary. It has an objective, constraints, success criteria, and non-goals.

Next, the iteration is divided into slices — vertical chunks of functionality with clear exit criteria. Progress is measured by completing slices, not checking off tasks.

The loop

The documents define the terrain. Once the plan is set, the daily mechanic is simple: I ask What next?

The agent reads the current state from the changelog and plan, then proposes one task. I read the proposal: what's the goal, what approach is being taken, what decisions are being made. If something feels off, I push back. If it's aligned, I approve.

This is the highest-leverage point in the workflow. It's cheaper to fix a bad decision before it's built than to refactor around it after.

The agent executes, then gives me a UAT checklist. I verify outcomes and skim the code. Every completed task updates the changelog — short entries about what changed, not how it was built. Over time, the changelog becomes shared memory for me and the agent.

Why it works

The agent's output is only as good as the scope I give it. A well-scoped task produces excellent code. A vague one produces invented decisions. So I control scope and decisions.

If I planned beyond the current slice, I'd be diluting that scope. The system works because it stays focused on a single iteration, a single slice, a single task.

There's no backlog and no task list. Just "What next?" — the agent reads the current state and picks up from there.