BigBrain · the human side

Who steers, and how.

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.

How a correction becomes a rule The owner corrects something. The correction is written as a memory file holding the rule, why it exists and how to apply it. A one-line pointer to the file goes into the index, MEMORY.md, and every later session loads that index before it replies. The owner corrects something A memory filethe rule · Why · How to apply A pointer in the indexone line in MEMORY.md The next session loads itthe index is read before the first reply
  1. 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.
  2. A header: name, one-line description, and type.A short header gives it a name, a one-line summary and a kind.
  3. 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.
  4. 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

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.

From an idea to main A requirements conversation produces a review artifact: a canvas of directions or a written proposal. The owner picks one, or sends it back and a new artifact is made. Only after the pick is a milestone of tickets filed. Agents build it in waves, each wave fast-forwards to main, and a milestone audit checks the result against the canvas the owner approved. Requirements conversationquestions until the plan holds A review artifactdirections A, B, C, or a proposal The owner picks A milestone is filedtickets, estimates, blocks edges Wavesa commit per ticket, one full run per wave maineach wave fast-forwards Milestone auditdesign-audit against the approved canvas sent back
Nothing gets filed until the owner picks.
Nothing starts until the owner chooses.
  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

    Full test runs, before and after waves Minutes of full-suite runs across one milestone, laid end to end, at one scale. Before: one full run of about ten minutes per ticket, seventeen runs or more, about 170 minutes, plus re-runs after rebases and after parallel runs collided and timed out. After: one full run per wave; with three waves, about 30 minutes, and each ticket runs only the tests that cover its change. Before: a full run per ticket 17 tickets, about 10 minutes each + re-runs parallel full runs collided and timed out; rebases forced more 0 min 60 min 120 min 180 min After: a full run per wave three waves, for example: about 30 minutes each ticket runs only the tests that cover its change never two full suites at once on the machine
    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.

  6. 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.

  7. 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.

Names, ids, hosts and credentials taken out.

Private details have been taken out.