Method

I treat AI agents like a team, not a tool.

Most people prompt. I run a program: briefs with non-negotiables, quality gates, decision logs, a budget, parallel workstreams and a retro after every phase. The agents write the code. I own what it has to do, how good it has to be, and when it's done.

01 · The Loop

Every change goes through the same six steps.

  1. 01

    Brief

    Write down what the thing must do and what it must never do before any code. Non-negotiables go at the top of the project's CLAUDE.md so every session reads them first.

    CLAUDE.md · non-negotiables

  2. 02

    Audit

    Before changing an app, ask whether it does the right job: walk the real workflows, map how data moves, rank bugs by harm. It ends in a visual page I can decide from on my phone.

    /product-audit · /app-architecture

  3. 03

    Mock up

    Proposed screens are drawn from the app's own tokens and real content, in desktop and phone frames, before anything is built. Words describing UI aren't enough to decide on.

    /ui-mockup

  4. 04

    Build in lanes

    Work is split into phases with a model, effort level and role each. Mechanical work goes to cheaper models running in parallel; judgment stays with the strongest one.

    subagents · worktrees · Model · Effort · Role

  5. 05

    Review

    Nothing is done until it's screenshotted at desktop and phone width and checked line by line: alignment, states, copy, contrast. I judge it by using it.

    /product-design · walk.mjs · shots.mjs

  6. 06

    Ship and log

    Commit and push at the end of every phase, deploy behind Cloudflare Access, and write down what was decided and why, in a decision log or in memory, so the next session doesn't relitigate it.

    git · Unraid · decisions.md · memory

02 · Skills I Wrote

When something works, I turn it into a skill.

Each of mine came out of a real project: I worked the process out on one app, then made it repeatable so every other app gets the same rigor without me re-explaining it.

/brand-identity210 lines · 7 refs · 7 scripts

Logo, wordmark, palette, type roles, a generated asset kit and a living brand guide, designed round by round, with every number derived from the typeface.

OriginA logo that took about thirty rounds to get right. Now any app gets the same discipline from round one.

/construction-review76 lines

Audits a chosen logo so every measurement (stroke weights, gaps, radii, overshoot) follows from a small system, and shows it rebuilt by those rules.

OriginWanting brand decisions that hold up to scrutiny, not just look right.

/product-design112 lines · 5 refs · 3 scripts

Interface rigor: semantic tokens, polished primitives, one home for every action, real phone layouts, precise copy, and a screenshot review pass before anything is called done.

OriginThe standard I held my most polished app to, written down so every app is held to it.

/product-audit145 lines · 3 refs

Whether an app does the right job in the right way, from workflows down to a corner radius. Ends in a decision page with diagrams, mockups, trade-off cards and a work plan.

OriginApps that felt like workarounds pieced together, and a bug where Postarr read nothing and reported all was well.

/ui-mockup77 lines

Mocks up proposed UI from the app's own tokens, components and real content, in device frames with numbered callouts and today-vs-proposed pairs.

OriginA plan that described UI in words I couldn't picture.

/app-architecture125 lines · 3 refs · 1 script

Holds every app to one standard: FastAPI + SQLite, Vite + React + TypeScript, one container on my home server behind Cloudflare Access, a port table, a phone layout that feels native.

OriginSix apps drifting into six stacks. Now they're a family and share code.

/workspace-audit171 lines · 6 refs · 3 scripts

Audits and tidies the AI workspace itself: config, memory, project folders, git and backup state, services. A verdict per item and a cleanup in approved phases.

OriginConfig and memory scattered across a year of experiments. Built to carry to a work machine.

/new-session105 lines

Starts a Claude Code session in any project in a new terminal workspace, with Remote Control on so I can follow and steer it from my phone.

OriginDoing the same five setup steps every time.

/new-app107 lines

The front door for a new app: the jobs it has to do and how often, a first version scoped to the most frequent one, the shaping decisions on a page to choose from, mockups, and a phased work plan that hands off to the other skills.

OriginSix apps that each found their plan halfway through the build. The next one starts with it.

/graveyard-shift185 lines · 2 scripts

Unattended work while I sleep: a few questions before I go, strict rules (no spending, nothing destructive, no deploys), a ledger so a cut-off session resumes, a watchdog that restarts it after the usage limit resets, and a morning page of choices to tap.

OriginThis site's overnight build, made repeatable.

/teardown77 lines · 4 scripts

Ends a session cleanly: checks that memory, commits and notes landed in the right place, removes scratch files, test servers and merged worktrees, then closes the terminal workspace.

OriginSessions started from my phone and left running on the Mac, with their test servers.

03 · The Harness

The setup around the model matters as much as the model.

Standing rules, memory, cost tracking and model choice, configured once so every session starts from the same standard.

Standing Rules

A global CLAUDE.md that reads like a team charter.

How to report to me, what never to touch, when to commit, when to ask. It loads into every session in every project, so I say it once.

# How to work in my projects
- My apps hold real data I use daily. Test on copies or
  throwaway data dirs. Never wipe, reseed or run
  destructive actions against live data.
- When I step away, keep going on everything you can
  do alone. If something needs a decision, add it to
  a table of open items and move on.
- Stop a line of work if a check fails; don't work
  around it.
- Ask before anything that costs money.

Memory

Corrections become rules, with the reason attached.

When I correct the agent, it saves the lesson as a memory with why it matters and how to apply it. There are 71 memory files across my projects, and the same mistake rarely happens twice.

---
name: step-handoff
type: feedback
---
After finishing any step of a multi-step plan, update
the plan page, republish it, and end with one explicit
"Next step" line.

Why: "I should have a very clear and explicit
signal for when the next thing to do is kick off."
How to apply: republishing is the step most often
skipped: do it in the same turn as the commit.

Model Choice

The right model and effort for each task, checked first.

Before any non-trivial task the agent reports the live model and effort and says whether to change them. Big runs are split: the strongest model for design and judgment, cheaper models for mapping and capture, in parallel.

Model Recommendation: 🟡 Update
- Model: Opus 5.5
- Effort: high
- Why: an unattended build where design polish is
  the whole point.

# lanes for tonight's run
Opus   · High   · Designer   site, copy, review
Sonnet · High   · Researcher ×4  capture + facts

Cost Awareness

Usage is measured, not guessed.

A custom status line logs each session's share of the five-hour usage window. A small report turns it into per-model rates, so a plan can say what a phase will cost before it starts.

$ tools/usage-report.py
WINDOWS (5-hour)
  ends        used  weighted tokens
  Wed 06:00   100%  opus 26,470k  → 0.38% per 100k
  Wed 12:30    99%  opus 27,673k  → 0.36% per 100k

SESSIONS
  opus medium   ≈ 19% of a window   36 min hands-on

# so a plan block can carry its cost up front
Sonnet · High · Builder   ≈ 10–20% of 5h

Remote Control

Long runs while I'm away, steered from my phone.

Sessions start with Remote Control on. Overnight runs keep a table of open decisions instead of stopping, and every hand-off is short enough to read on a phone, with the detail in a linked page.

Hooks

Checks that run themselves, before every commit and every deploy.

One global hook runs a repo's checks before Claude can commit, and blocks the commit if they fail. Every deployed app's deploy script runs them again and ships nothing on a failure. A second hook notices when the shared phone standard changes and sends the session back to sweep the apps.

# ~/.claude/hooks/check-before-commit.sh
PreToolUse · Bash · git commit
  repo has scripts/check.sh? run it
  failing? block the commit, show the output

$ scripts/deploy.sh
Postarr        282 api · 154 web          ✓
cue            421 api ·  36 web          ✓
macro-meeter    82 api ·  56 web · 44 iOS ✓
# a failing check ships nothing

04 · Why A TPM

Program management turns out to be the skill AI needs.

Scope and requirements

Briefs with non-negotiables written before the work: "A dead source is never a clean result." "Never assert an authority you do not have."

Reconcilarr's CLAUDE.md

Risk management

Live data is off-limits by rule, so tests run on copies and throwaway data dirs. Backups come before migrations. Anything that costs money asks first.

global CLAUDE.md · this site's capture brief

Decision records

Every brand round and design call is logged with its reason, so a later session can't quietly undo it.

mothership decisions.md (24 brand rounds) · arrs-common decisions.md

Resourcing and budget

Model and effort chosen per phase. Cheap models do mechanical work in parallel, and usage is measured per model to estimate the next plan.

status-line usage log · usage-report.py

Parallel workstreams

Big tasks are split into lanes that run at once in subagents and git worktrees, then merged and reviewed.

arrs audit: 3 mappers in parallel · this site: 4 capture agents

Quality gates

"Done" means screenshotted at two widths and reviewed against a checklist, plus a construction review for any logo. Tests run before every commit, and a failing one stops a deploy.

/product-design review.md · check-before-commit hook

Stakeholder updates

Decisions arrive as visual pages: diagrams, mockups, trade-off cards, a work plan. The status says what's done, what's next and what's blocked.

/product-audit decision pages

Retros

After each app, the skills are improved from what went wrong or took too long. The process gets better with every project.

skills repo: 115 commits in 53 days

05 · Where I'm Going

I keep a growth plan, and I grade myself against it.

The first five tiers are the common ladder for working with AI, from chatting to building tools for others. All five are done, the fifth at work. Past them the ladder is my own: what I'm working on now, and what comes after.

  1. 1

    Chat and copy-paste

    Ask a chatbot, paste the answer somewhere.

    ✓ Done
  2. 2

    Build apps with an agent

    Working software, mostly by conversation.

    ✓ Done
  3. 3

    Ship real software, reuse the process

    Deployed apps in daily use; process captured as skills and memory.

    ✓ Done
  4. 4

    Configure the harness

    Per-task model choice, cost awareness, parallel agents, hooks, gated deploys, and checks that run on every push with no one starting them.

    ✓ Done
  5. 5

    Build tools for others

    AI tooling other people use, built at work (not shown here).

    ✓ Done
  6. 6

    A second reader on every change

    Every change that ships goes through a pull request and an AI code review, small ones included. Started November 3; it has already caught bugs that every test passed.

    ◐ In progress
  7. 7

    Agents on call

    An alert opens a session that investigates, reports and changes nothing; a fix waits for my approval. Mothership does the first half today.

    ◐ In progress