Rules I worked by until the evidence broke them, oldest first.
By June 2025
Generating the code is the hard part.
My first AI builds started in a code generator (V0) and ended in disorganized files. Moving code between a chat window and the editor (Claude and Cursor) meant endless copy-paste and error-correction loops.
The model works in the repository itself, first through a file-server connection (MCP) and now from the terminal (Claude Code).
By June 2025
The model remembers what it already built.
On Mixed Signals, my first large AI-built app, the model lost track of its own earlier work, and building the front end and back end at once created cascading errors.
I build the front end before the back end, and the model works from a written error log and task list instead of its memory.
By June 2025
Better prompts are enough to control the model.
Rules documents, research reports, and project personas improved my control of the model, but I still lacked control over how each project started and was tracked.
Every project starts from four files the model generates and then works against: the project brief, the rules, the plan, and the task list.
By June 2025
The strongest general model is the right one for every job.
Building automation workflows (n8n), an agent tool (Manus) produced a working automation and outperformed the other models I tried.
I pick the model by the job. That habit became the role table on this page.
October 2025
An agent can grade its own work.
An agent pipeline I built had an agent check its own output and approve it once its confidence reached 0.90. On one change it reported 0.985 confidence and a passing build while the deploy failed, and the code it had written took six fixes for render and reload loops the next morning.
I dropped the pipeline after two changes. Code is now reviewed by a different model family than the one that wrote it, and nothing merges without me.
December 2025
An optimizer makes a prompt better.
An automatic optimization pass (DSPy) grew a product-requirements prompt from about 1,000 words to about 3,000 without making it better.
I switched to an optimizer (GEPA) scored on a metric that penalizes a prompt for growing.
By September 2026
Passing checks mean the code is right.
A file written by the implementing model (Codex) passed type checks, tests, and lint with corrupted bytes: a stray byte-order mark and double-encoded characters. A reviewer from a different model family caught what every check had passed.
Review comes from a different model family than the author, and every diff gets a byte check before it is committed.
2026-09-08
Each review finding describes a real risk on my machine.
A reviewer from a different model family, reading code the implementing model (Codex) wrote, found a window where an interrupt would delete the backup of a file the module existed to protect. Nothing else had caught it. Another finding, about backups under a symlinked settings file, did not apply when measured: the file was not a symlink.
Every review finding is a hypothesis, checked against the code or a measurement before it changes the plan. A cheap guard for a risk that does not apply yet can stay.
2026-09-13
A measured zero means the thing never happened.
A plan to change how my agents decide when to consult my library rested on a count of zero: they never did it on their own. I asked whether we had already built this. A four-minute check of the raw session records found 4, not 0. The counting tool could not see the event it was counting.
Before a zero becomes a premise, I check that the instrument could have shown anything else.
2026-09-28
Calling the coding model through its plugin integration is the simplest route.
The integration (Codex over MCP) could stall silently, waiting for approvals nobody was there to give, and the vendor later dropped the command it relied on.
Work goes to the coding model through its command line, under a supervisor that names the model and effort for every job and records what each job did.
2026-10-15
More reviewers means better review.
I audited 119 decisions by the design model (Fable). On design and product questions it found things the others missed. On CI, evaluation, schema, and test-policy questions it mostly agreed with the model that wrote its brief, which is confirmation, not review.
It stays on design and product-intent decisions and no longer sits on the other panels.
2026-10-15
A question I can measure is one I should measure.
An audit left open whether the senior coding model wrote better code than the routine one. A fair test meant splitting about eight real units of work between them, and with the cost acceptable I chose not to run it.
I kept the senior model on architecture-bearing work and wrote down what would reopen the question: rising cost or more escaped defects.
2026-11-03
Writing down a lesson can wait until merge.
Of about 14 lesson-capture attempts deferred to merge, none ran.
When a change adds something the plan did not ask for, or a debugging guess turns out wrong, the capture attempt runs before the PR opens, and the PR records whether a lesson was written or why it was skipped.
2026-11-03
A safeguard that answers a real incident is always justified.
Many of the safeguards in one cleanup tool traced to real failures, yet together they had grown it to about 7,000 lines of code and 14,000 of tests, for a job whose core is cleaning up while saving any unmerged work.
I adopted a rule to choose the smallest adequate solution: a fix names the safeguards it makes redundant and removes them, and one tested recovery path is enough where harm cannot be undone.
The rule in my public workflow notes2026-11-12
A model that looks strong belongs in the workflow.
I gave a new reviewer model (Kimi) a dated trial with an early-stop check instead of a seat. At its five-PR checkpoint it had caught scope misses on four of the five.
It stays as an advisory reviewer: it owns no gate, and its findings count only after another reviewer checks them against the plan and the source.