The Architecture page covers the agents. This one covers the person steering them and the habits we've built up in Claude Code and Codex. Quotes come from the real files, with private details taken out.
The Architecture page is about the AI helpers. This one is about the person directing them and the habits we've built up: saved instructions, a memory of every correction, one path for big ideas, and a few rules that each exist because something broke. Quotes come from the real files with private details taken out.
Skills: say it once
A skill is a markdown file Claude Code pulls in when a request matches its description; Codex sessions reach the same skills through adapters. These are the ones that actually get used, counted across the owner's 133 most recent sessions and the agents they started.
A skill is a saved set of instructions I pick up when a request fits, on either AI tool the owner uses. These are the ones that actually get used, counted across the owner's 133 most recent conversations.
file-ticket
In 79 sessions, more than half. Nobody types it: I load it every time work gets filed. Every ticket gets a project, milestone, estimate and real blocking links, and two that touch one file go in order.
In more than half of all conversations, and never typed: I use it whenever work gets written up. Every task gets written up the same way, and two that edit one file go in order.
Edges, not prose. A real dependency is a blocks relation.
estimate-work
In 43 sessions, mostly loaded by agents before they size a ticket. A forecast comes from measured runs of comparable work, one point is a fixed slice of predicted minutes, and "unknown" is a valid answer.
Used whenever a task needs a size. The guess comes from how long similar work really took, and "we don't know yet" is an allowed answer.
Do not infer execution time from human hours, chat length or old ticket points.
/status-update
In 35 sessions, and now the skill the owner types most. Done, running, left, and what only the owner can decide, each claim checked against what landed.
The skill the owner types most. I say what's done, what's running, what's left and what needs their decision, and only call something done once I've checked.
An old stage file or ticket state alone does not prove work is active.
/app-build
In 13 sessions. Patch notes first, reviewed in chat, then one test build per platform from main, uploaded only once the owner approves it from their phone.
Builds a test version of Dice Lock for testers. The owner reads the release notes before anything goes out and approves the upload.
Approving a build does not approve its notes.
/finish
In 10 sessions. Test, check the count didn't drop, commit, close the ticket, pick up whatever it was blocking.
Run the checks, save the work, close the task and move straight on to the next.
A ticket that is 80% done is not finished, and closing it is worse than leaving it open: the graph will start its successors.
/start
In 8 sessions. Start of day: I drop blocked and running tickets and offer three at most, each marked for the owner or an agent.
At the start of the day. I suggest up to three things to work on and say who should do each.
The point of the triage half is a decision, not a list.
grilling
In 6 sessions, each the start of something big. I question the owner in rounds, one layer of decisions at a time, each question with my recommended answer, until nothing is left assumed.
Used at the start of anything big. I ask questions in rounds, each with my suggested answer, until nothing is left to guess.
Finding _facts_ is your job, never the user's.
/playtest
In 3 sessions. Six blind tester agents, each a different kind of player, play Dice Lock through a harness and report what confused them.
Six AI testers, each playing like a different kind of person, try Dice Lock cold and report where they got stuck.
Nothing else, no cost estimate and no confirmation: typing /playtest is the go-ahead.
job-queue
In 2 sessions. Reads the one queue every background agent waits in: what's running, what's behind it, and what died without saying so.
Answers why a background job hasn't started yet.
"Why hasn't my job started?" is therefore usually a queue question, not a dispatch question.
unslop
In 2 sessions. Flags the patterns that make prose read as machine-written, and rewrites only when asked.
Finds the phrases that make writing sound like AI, and fixes them only when asked.
Audit first. Rewrite only when the user asks for a rewrite.
monitor-endpoints
In 1 session. A live watch on every public address and route, reporting only changes. A scheduled sweep runs the machine's health checks, files what it finds into a Bugs milestone and cancels what clears.
Checks that every public page and connection stays up. A regular check files anything broken as a bug and closes it once it's fixed.
A single sweep only proves the tunnel was up at one instant.
design-audit
In 1 session. Checks an approved design against the tickets and the shipped build, frame by frame, and says what never reached production.
Compares an approved design with what actually shipped, and lists what's missing.
A ticket's state is not where its code is, and a passing suite is not a screen.
Built-in skills
Claude's own design skills, artifact-design (11 sessions), dataviz and artifact-diagramming, load whenever I draw a canvas or proposal for the review gate. The owner has never typed one.
Claude's own design skills load whenever I draw up options for the owner to choose from. The owner never calls them.
/clear
Typed 120 times, before most new tasks. Each task starts in a fresh session; whatever needs to carry over lives in memory, not in a long conversation.
The owner's most-typed command by far. Each task starts with a clean slate, and anything worth keeping is in memory, not in an old conversation.
Memory: corrected once
When the owner corrects me, it's saved to a file and every later session starts out knowing it. There are about 160.
When the owner corrects me, it gets saved, and every conversation after that starts out knowing it. There are about 160 now.
One fact per file, so a rule can change or go without touching the others.One rule per note, so each can be changed or dropped on its own.
A header: name, one-line description, and type.A short header gives it a name, a one-line summary and a kind.
The rule, why it exists in the owner's words, and how to apply it.Then the rule, why it exists in the owner's own words, and how to follow it.
An index, MEMORY.md, gives each file one line and loads every session. Past its size limit it gets cut off, so lines stay short.An index with one line per note is read at the start of every conversation. Anything past its size limit gets cut off, so the lines stay short.
Six of them, and what prompted each
Default to brief
Default to the short answer. Give the conclusion, the decision, or the instruction, and stop there.
My answers ran several times longer than the decision in them.
My answers were much longer than their point.
Act, don't hand back procedures
a fix that sits uncommitted in a working tree is not delivered.
I fixed a bug, then asked whether I should commit it.
I fixed something, then asked permission to save it.
Split multi-part asks
When a message contains more than one distinct ask, split them into separate parallel investigations rather than researching them as one blended pass.
I answered two unrelated questions in one long blended pass.
I treated two unrelated questions as one.
No trailing gap observations
Either make the change, ask the question up front, or say nothing.
Three replies in a row ended with "one gap worth knowing".
My replies kept ending with a loose "one more thing".
Agent reports: only what matters
Evidence is still wanted, but as one number or commit per claim, not the process of getting it.
Ticket comments ran to 1,400 characters. Code now caps them at one summary sentence and a short list of changes.
Agents' reports read like long stories. Now the system won't accept long ones.
The owner decides app builds
Say the fix is waiting on a build and stop there.
I offered to cut an app build nobody had asked for.
I offered to release an app version nobody had asked for.
From idea to shipped
Big work goes the same way every time. The owner steps in twice: to pick a direction before anything is filed, and to decide when an app build goes out.
Big work follows the same steps every time. The owner steps in twice: to choose a direction, and to decide when a new app version goes out. The rest is mine.
Nothing gets filed until the owner picks.
Nothing starts until the owner chooses.
Talk it through
The owner describes what they want and I ask questions until the requirements stop moving. For big decisions, a grilling skill goes after every weak spot.
The owner describes what they want, and I keep asking questions until the plan holds up.
The review gate
I publish something to look at: a canvas with a few directions, or a proposal with options. The owner picks one or sends it back. Nothing big gets built before that.
I put together a few design options, or a written proposal, for the owner to look at. They pick one or send it back. Nothing big gets built before that.
File a milestone
Then file-ticket turns the pick into one milestone, named for what it delivers.
Then the chosen plan becomes one batch of tasks.
Build in one session
One session splits the milestone across agents working side by side, each in its own worktree. Eleven tickets took 87 minutes; one at a time took 11 hours.
One session hands the batch to several helpers working side by side. Eleven tasks took 87 minutes that way, where one at a time took 11 hours.
Test in waves
What went wrong
Every ticket used to be pushed the moment it was done, and every push meant a ten-minute full test run: 17 or more per milestone, plus re-runs after rebases, and parallel suites timed each other out. The test runs were the cost, not the tickets.
Every finished task used to set off the full set of checks, about ten minutes each. That came to 17 or more runs per batch, and helpers checking at the same moment knocked each other over. The checks were the cost, not the number of tasks, and merging everything into one giant task would have lost the teamwork and the save points.
What changed
Now each agent commits to a milestone branch and runs only the tests for its change. The full suite runs once per wave, never two at once, then the wave goes to main.
Now each helper saves its task to a shared batch and runs only its own checks. The full checks run once per group, never two at a time, and then the group goes live.
The owner's call
We have to test the full suite anyway by the end of the milestone. After the milestone is when we will make new builds.
Audit against the canvas
The finished milestone is audited once, and design-audit checks it against the canvas the owner picked.
When the batch is done, it's checked once against the design the owner chose.
Builds and the daily loop
Pushing to main publishes the websites. App builds wait for the owner. Small jobs just use /start and /finish.
Saving to the main copy publishes the websites; a new app version waits until the owner asks. Small jobs skip all of this and use /start and /finish.
Rules that came from breakages
Most of what every session reads first is rules like these, each there because its absence cost something.
Most of what every AI session reads first is rules like these. Each one is there because something broke without it.
Never git reset --hard or git clean -fd in a checkout you did not create.
Checkouts hold other agents' uncommitted work. A helper called with no arguments once fell back to the main checkout and wiped seven uncommitted files.
Helpers share folders. One clean-up aimed at the wrong folder wiped seven files of unsaved work.
A missing sibling must be LOUD.
A require wrapped in a catch once returned a stub, so commands passed against a mock while health stayed green. Now a missing repo throws or turns health red.
A missing piece was once quietly faked, so everything looked fine when it wasn't. Now it stops the work or turns the status page red.
A test file that stops running because it landed in the wrong repo is otherwise invisible.
So suite totals get compared before and after any structural change.
So the checks get counted before and after code moves.
One commit per ticket, pushed immediately. Never --no-verify, never force-push, and never bundle unrelated changes.
Broken anyway, once, by a reflexive force-push. A git hook now refuses any push that rewrites a remote branch.
It got broken anyway. Now the system refuses any upload that rewrites history.
A fresh headless dispatch, one ticket and no memory, must find a repo's domains, interfaces, features and errors from the tree alone.
That's the fleet standard: ten practices, each with a conformance test in every repo.
Every project is laid out the same way, and automatic tests keep it that way.