{
  "site": "https://chiefofagents.si",
  "author": "Tanvir",
  "parts": [
    {
      "n": 1,
      "slug": "choose-the-problem",
      "title": "Choose the problem",
      "line": "Decide what is worth building before any agent writes code.",
      "url": "https://chiefofagents.si/parts/choose-the-problem"
    },
    {
      "n": 2,
      "slug": "assign-the-work",
      "title": "Assign the work",
      "line": "Hand over a slice so a fresh agent can pick it up cold.",
      "url": "https://chiefofagents.si/parts/assign-the-work"
    },
    {
      "n": 3,
      "slug": "set-the-boundaries",
      "title": "Set the boundaries",
      "line": "Give agents hours of freedom without giving them your authority.",
      "url": "https://chiefofagents.si/parts/set-the-boundaries"
    },
    {
      "n": 4,
      "slug": "judge-the-result",
      "title": "Judge the result",
      "line": "Tell a claim of done from proof of done.",
      "url": "https://chiefofagents.si/parts/judge-the-result"
    },
    {
      "n": 5,
      "slug": "make-it-stick",
      "title": "Make it stick",
      "line": "Turn each failure into something the next agent cannot miss.",
      "url": "https://chiefofagents.si/parts/make-it-stick"
    },
    {
      "n": 6,
      "slug": "what-stays-mine",
      "title": "What stays mine",
      "line": "Three decisions that never leave my hands.",
      "url": "https://chiefofagents.si/parts/what-stays-mine"
    }
  ],
  "lessons": [
    {
      "n": 1,
      "slug": "the-agent-interviews-me-first",
      "part": 1,
      "partSlug": "choose-the-problem",
      "title": "The agent interviews me first",
      "line": "Before any code, the agent asks every question that would change what it builds.",
      "rule": "Settle the unclear parts before building, and record the answers somewhere that outlives the conversation.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-1",
      "howIDoIt": "In my workflow this interview is a skill called Grill Me, made by Matt Pocock. The agent reads first, asks second, and never asks something the files already answer.",
      "incident": null,
      "body": [
        "The first agent does not start by writing code. It reads whatever context already exists, then works out which open decisions would change the build.",
        "It asks all the blocking questions together, in one batch. Each question comes with a recommendation and what that choice would cost. I answer once, and the answers are written down as project decisions, outside the chat."
      ],
      "concepts": [
        "what-is-a-chief-of-agents"
      ],
      "url": "https://chiefofagents.si/lessons/the-agent-interviews-me-first",
      "text": "https://chiefofagents.si/lessons/the-agent-interviews-me-first.md"
    },
    {
      "n": 2,
      "slug": "one-source-of-truth",
      "part": 1,
      "partSlug": "choose-the-problem",
      "title": "Give the project one source of truth",
      "line": "One document says what the product is, who it is for and which decisions are mine.",
      "rule": "Write one PRD for the project, keep it under version control, and start every agent from it.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-2",
      "howIDoIt": "I call it the PRD. Every agent on the project reads it before anything else.",
      "incident": null,
      "body": [
        "A product requirements document records the product, its users, the outcomes, the limits, the architecture choices and the points where only I approve. It also maps the project into complete slices.",
        "It stops different agents from building on different assumptions. It does not hold every detail; each slice has its own documents. This one is the contract for the whole project.",
        "Changes are tracked in the document, so they are not lost inside a chat."
      ],
      "concepts": [],
      "url": "https://chiefofagents.si/lessons/one-source-of-truth",
      "text": "https://chiefofagents.si/lessons/one-source-of-truth.md"
    },
    {
      "n": 3,
      "slug": "stop-building-in-layers",
      "part": 1,
      "partSlug": "choose-the-problem",
      "title": "Stop building frontend, backend, then database",
      "line": "Three finished layers can add up to nothing a user can do.",
      "rule": "Cut work by what a user can do, never by technical layer.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-3",
      "howIDoIt": "Every piece of work I hand to agents is cut this way: user action, interface, API, database, visible result.",
      "incident": null,
      "body": [
        "In a layer-by-layer build, the interface gets finished, then the backend, then the database. Each one looks done. No user can complete a single task, and the risk of joining them stays hidden until late.",
        "In a vertical slice, the team builds one narrow path through every layer it needs. It starts with something a user does and ends with something they can see. The slice is small, and it works as a product."
      ],
      "concepts": [
        "what-is-a-vertical-slice"
      ],
      "url": "https://chiefofagents.si/lessons/stop-building-in-layers",
      "text": "https://chiefofagents.si/lessons/stop-building-in-layers.md"
    },
    {
      "n": 4,
      "slug": "prove-one-complete-path-first",
      "part": 1,
      "partSlug": "choose-the-problem",
      "title": "Prove one complete path first",
      "line": "The first slice exists to show you which of your assumptions are wrong.",
      "rule": "Build one thin, complete journey and test it end to end before you build wider.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-4",
      "howIDoIt": "The project chat builds the first tracer itself, before any slice is handed to another chat.",
      "incident": null,
      "body": [
        "Start with the smallest real user journey. Touch every layer needed to make it work. Test the whole journey before adding anything beside it.",
        "That first slice is a tracer bullet. It shows the wrong assumptions while they are still cheap, before the team repeats them across the whole product."
      ],
      "concepts": [
        "what-is-a-tracer-bullet",
        "what-is-a-vertical-slice"
      ],
      "url": "https://chiefofagents.si/lessons/prove-one-complete-path-first",
      "text": "https://chiefofagents.si/lessons/prove-one-complete-path-first.md"
    },
    {
      "n": 5,
      "slug": "every-slice-gets-a-takeover-packet",
      "part": 2,
      "partSlug": "assign-the-work",
      "title": "Every slice gets a takeover packet",
      "line": "Everything a new engineer would need to take over the work cold.",
      "rule": "Write the takeover packet after the work is verified, and write it for someone who knows nothing.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-5",
      "howIDoIt": "In my setup the lead agent writes the next setup brief as its last step, and it is the only one that writes the state file.",
      "incident": null,
      "body": [
        "A takeover packet has four parts. The PRD and the full slice map. A setup brief with scope, decisions, dependencies and exit tests. A session-start brief: instructions ready to paste into a fresh chat. And the verified state: the real branch, commit, evidence, blockers and what still needs approval. In my setup these are four files: the PRD, the slice spec, the kickoff prompt and the state file. The kickoff prompt stays on my machine, out of git.",
        "The lead agent writes the takeover packet for the next slice, after the work is verified. Builders and checkers send it their updates. A packet written before the work is done describes a prediction. One written after describes what is true."
      ],
      "concepts": [
        "what-is-a-takeover-packet"
      ],
      "url": "https://chiefofagents.si/lessons/every-slice-gets-a-takeover-packet",
      "text": "https://chiefofagents.si/lessons/every-slice-gets-a-takeover-packet.md"
    },
    {
      "n": 6,
      "slug": "git-carries-truth-between-chats",
      "part": 2,
      "partSlug": "assign-the-work",
      "title": "Git carries truth between chats",
      "line": "Chat history is temporary. The repository lasts.",
      "rule": "Make the unit of work a verified outcome in the repository, so any fresh agent can continue from it.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-6",
      "howIDoIt": "One project chat, then one chat per slice. Each ends with a merge and a recorded state.",
      "incident": null,
      "body": [
        "The project chat creates the PRD and the first tracer. After that, each slice gets its own focused chat, its own feature branch and its own pull request.",
        "When a slice finishes, the agent records the verified state and prepares the next setup brief. The next chat starts from committed code and documents. It does not start from a copied conversation.",
        "There is no automatic memory shared between the chats. Git carries what is true."
      ],
      "concepts": [
        "what-is-a-takeover-packet"
      ],
      "url": "https://chiefofagents.si/lessons/git-carries-truth-between-chats",
      "text": "https://chiefofagents.si/lessons/git-carries-truth-between-chats.md"
    },
    {
      "n": 7,
      "slug": "more-freedom-needs-more-structure",
      "part": 3,
      "partSlug": "set-the-boundaries",
      "title": "More freedom needs more structure",
      "line": "The longer an agent runs alone, the more has to be written down first.",
      "rule": "Replace watching with writing. What you would have caught by looking has to be caught by a rule.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-7",
      "howIDoIt": "The amount I write before a run grows with the length of the run.",
      "incident": null,
      "body": [
        "An assistant inside your editor works under constant supervision. You see each change and correct it straight away. An agent working alone for hours gets none of that.",
        "So longer freedom needs more written structure: scope, permissions, state, what counts as evidence, budgets and conditions that stop the run.",
        "My approval moves away from individual keystrokes and onto the decisions that cannot be undone."
      ],
      "concepts": [
        "what-is-a-run-contract",
        "what-is-an-afk-run",
        "what-is-a-chief-of-agents"
      ],
      "url": "https://chiefofagents.si/lessons/more-freedom-needs-more-structure",
      "text": "https://chiefofagents.si/lessons/more-freedom-needs-more-structure.md"
    },
    {
      "n": 8,
      "slug": "a-lead-agent-and-specialists",
      "part": 2,
      "partSlug": "assign-the-work",
      "title": "One lead agent, and specialists",
      "line": "One agent owns the slice. The others get narrow tasks.",
      "rule": "Give every agent one task and one owner, and keep the one who built it away from the one who approves it.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-8",
      "howIDoIt": "The number of agents matters less than how clear their assignments, shared state and authority are.",
      "incident": null,
      "body": [
        "One lead agent owns the slice. It hands narrow, independent tasks to builders, testers and reviewers. Each works in its own Git worktree, so two agents never overwrite each other.",
        "Builders implement. Checkers verify. One integrator owns the final diff and the commit history. The builder never approves its own work.",
        "The lead owns the outcome, specialists own their assignments, checkers produce independent evidence, and I decide whether the result passes a human gate."
      ],
      "concepts": [
        "what-is-sub-agent-driven-development"
      ],
      "url": "https://chiefofagents.si/lessons/a-lead-agent-and-specialists",
      "text": "https://chiefofagents.si/lessons/a-lead-agent-and-specialists.md"
    },
    {
      "n": 9,
      "slug": "loop-or-graph",
      "part": 2,
      "partSlug": "assign-the-work",
      "title": "Loop or graph",
      "line": "A loop improves one task. A graph coordinates several.",
      "rule": "Reach for the simple shape first.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-9",
      "howIDoIt": "Most of my work is loops. A graph appears when a slice has real specialists that need to branch and rejoin.",
      "incident": null,
      "body": [
        "A loop improves one bounded task through repeated checks. It plans, builds, verifies, fixes, and leaves when the result passes.",
        "A graph coordinates several tasks, tools and decisions. Shared state keeps every agent aligned. The connections between steps decide what runs, what retries, what pauses and what stops.",
        "Start with a loop. Add a graph when the work needs it."
      ],
      "concepts": [
        "loop-vs-graph"
      ],
      "url": "https://chiefofagents.si/lessons/loop-or-graph",
      "text": "https://chiefofagents.si/lessons/loop-or-graph.md"
    },
    {
      "n": 10,
      "slug": "what-the-graph-holds",
      "part": 2,
      "partSlug": "assign-the-work",
      "title": "What the graph holds",
      "line": "Builder, tester, security reviewer, checks, an evidence pack and a gate only I can open.",
      "rule": "If several agents share a task, write down the state they all read from.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-10",
      "howIDoIt": "Five things are always in shared state: scope, diff, evidence, status and budget.",
      "incident": null,
      "body": [
        "The graph I run has a lead agent, a builder, a tester and a security reviewer, each running its own loop. Their work passes through automated checks into an evidence pack, and stops at the merge gate.",
        "Underneath runs shared state: scope, diff, evidence, status and budget. Failed work goes back to the builder.",
        "Graphs cost coordination. Use one when the work needs real specialists, branching or shared state."
      ],
      "concepts": [
        "loop-vs-graph",
        "what-is-an-evidence-pack"
      ],
      "url": "https://chiefofagents.si/lessons/what-the-graph-holds",
      "text": "https://chiefofagents.si/lessons/what-the-graph-holds.md"
    },
    {
      "n": 11,
      "slug": "preparing-an-afk-run",
      "part": 3,
      "partSlug": "set-the-boundaries",
      "title": "Preparing an AFK run",
      "line": "Five things I do before I walk away.",
      "rule": "Decide before you leave what the agent may never do, and make it stop when it gets there.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-11",
      "howIDoIt": "AFK means away from keyboard. My runs last five or six hours.",
      "incident": null,
      "body": [
        "One: every blocking question gets asked before the run begins. Two: choices that can be undone are separated from decisions only I can make. Three: permanent fences, budgets and stop conditions are written down. Four: the branch and a draft pull request are open before I leave. Five: every claim of completion has to come with evidence.",
        "The fences stay in force the whole time. Mine forbid force-pushing, exposing secrets, changing the production database, merging code and publishing. The run carries on through safe work that can be undone, and stops when a protected action becomes necessary, unless that run carries a written grant for it."
      ],
      "concepts": [
        "what-is-an-afk-run",
        "what-is-a-run-contract"
      ],
      "url": "https://chiefofagents.si/lessons/preparing-an-afk-run",
      "text": "https://chiefofagents.si/lessons/preparing-an-afk-run.md"
    },
    {
      "n": 12,
      "slug": "sequence-loop-or-graph",
      "part": 2,
      "partSlug": "assign-the-work",
      "title": "Sequence, loop or graph?",
      "line": "Choose the simplest shape that matches the work.",
      "rule": "Use a checklist when a checklist does the job.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-12",
      "howIDoIt": "I ask it in this order, and stop at the first one that fits.",
      "incident": null,
      "body": [
        "A sequence handles steps that depend on each other and run once. A loop repeats one task until it meets an exit condition. A graph coordinates specialists that branch, rejoin, retry and escalate.",
        "Picking the simplest one prevents a common failure: building a complicated coordination system for work a checklist could have finished."
      ],
      "concepts": [
        "loop-vs-graph"
      ],
      "url": "https://chiefofagents.si/lessons/sequence-loop-or-graph",
      "text": "https://chiefofagents.si/lessons/sequence-loop-or-graph.md"
    },
    {
      "n": 13,
      "slug": "anatomy-of-an-afk-run",
      "part": 3,
      "partSlug": "set-the-boundaries",
      "title": "Anatomy of an AFK run",
      "line": "It starts with a contract and ends at a gate. Nothing in between merges without my yes.",
      "rule": "Design the run so the most it can do without you is prepare a decision, or carry out one you granted in writing before you left.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-13",
      "howIDoIt": "Five or six hours, one contract in, one draft pull request out.",
      "incident": null,
      "body": [
        "I start the run with one batch of decisions and a contract. The contract sets scope, permissions, permanent fences, a budget, stop conditions and exit tests.",
        "The lead agent coordinates separate lanes for building, testing and collecting evidence. The lanes write to shared state. If one lane needs a credential or a decision from me, that lane stops. Safe, independent work carries on.",
        "The work rejoins at independent review. Failed review goes back to implementation. Passing work produces an evidence pack and a draft pull request. Then the run stops at the merge gate and waits for me, unless I gave that yes in writing before it began.",
        "Nothing reaches production any other way. Being away changes when I supervise. It does not change what I own."
      ],
      "concepts": [
        "what-is-an-afk-run",
        "what-is-a-run-contract",
        "what-is-a-human-gate"
      ],
      "url": "https://chiefofagents.si/lessons/anatomy-of-an-afk-run",
      "text": "https://chiefofagents.si/lessons/anatomy-of-an-afk-run.md"
    },
    {
      "n": 14,
      "slug": "returning-at-the-merge-gate",
      "part": 4,
      "partSlug": "judge-the-result",
      "title": "Returning at the merge gate",
      "line": "I read the evidence, then decide what ships.",
      "rule": "Make the thing you review small, single-purpose and tied to one exact commit.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-14",
      "howIDoIt": "The real evidence pack shown on this site says it plainly: PASS, 11 of 11 checks, 17 of 17 tests, and \"Not done here: merge, production database changes.\"",
      "incident": null,
      "body": [
        "Review finishes before the work reaches me. One pull request tells one story I can trace. Changes that would make review unclear get separate pull requests.",
        "The checks have to be green on the exact commit proposed for merge, not on an earlier one.",
        "I do not replay every step the agents took. I review the evidence and decide."
      ],
      "concepts": [
        "what-is-a-human-gate",
        "what-is-an-evidence-pack"
      ],
      "url": "https://chiefofagents.si/lessons/returning-at-the-merge-gate",
      "text": "https://chiefofagents.si/lessons/returning-at-the-merge-gate.md"
    },
    {
      "n": 15,
      "slug": "after-the-code-works",
      "part": 4,
      "partSlug": "judge-the-result",
      "title": "What happens after the code works",
      "line": "Working code starts the delivery. It does not finish it.",
      "rule": "Treat \"it works here\", \"it is deployed\" and \"it works for users\" as three different claims.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-15",
      "howIDoIt": "CI is the automated checks on the proposed change. CD is the automatic deployment after I approve a merge.",
      "incident": null,
      "body": [
        "The application travels one path: a feature branch, a pull request, automated checks, a preview environment, independent review, my merge, automatic deployment, live verification, and then real users.",
        "Database changes travel a second path: an additive migration, verification against a test database, my approval for production, and confirmation that production is ready. The two paths join before the merge.",
        "Deployment is not proof. Checking the live system is a separate step."
      ],
      "concepts": [
        "what-is-an-additive-migration",
        "what-is-a-human-gate"
      ],
      "url": "https://chiefofagents.si/lessons/after-the-code-works",
      "text": "https://chiefofagents.si/lessons/after-the-code-works.md"
    },
    {
      "n": 16,
      "slug": "keep-secrets-out-of-sight",
      "part": 3,
      "partSlug": "set-the-boundaries",
      "title": "Keep secrets out of sight",
      "line": "An agent can read files, terminal output and process details. A secret can be in all three.",
      "rule": "Assume anything an agent can print, it can read.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-16",
      "howIDoIt": "Values live in a secret store and are injected at runtime. My notes and docs only ever name the variable.",
      "incident": "A command that inspects running processes printed secrets that the secret store had injected into a running process. They went straight into the agent's output.",
      "body": [
        "Plain-text secrets in a file beside the code are the obvious risk. The less obvious one is that a secret can reach the model even when the repository holds no such file.",
        "The fix covers the whole path. A secret store keeps values outside the repository. Commands receive values only when they run. Documentation holds variable names, never values. Secret scans check changes before they land. And process output is treated as a possible source of secrets too."
      ],
      "concepts": [
        "how-do-ai-agents-leak-secrets"
      ],
      "url": "https://chiefofagents.si/lessons/keep-secrets-out-of-sight",
      "text": "https://chiefofagents.si/lessons/keep-secrets-out-of-sight.md"
    },
    {
      "n": 17,
      "slug": "never-test-against-production-data",
      "part": 3,
      "partSlug": "set-the-boundaries",
      "title": "Never test against production data",
      "line": "Agents need somewhere they can break things.",
      "rule": "Give agents a full copy of the shape of production and no route to the real thing.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-17",
      "howIDoIt": "My isolated branch is called v2-test. Only test migrations run there.",
      "incident": null,
      "body": [
        "Tests run against an isolated database branch, with separate test data and separate permissions. Agents can run migrations, create records and exercise failures there without touching a real customer.",
        "The isolation covers four things: where the connection points, the data, the permissions and the migration path. A test command must point only at the isolated environment. A test has no path to production."
      ],
      "concepts": [],
      "url": "https://chiefofagents.si/lessons/never-test-against-production-data",
      "text": "https://chiefofagents.si/lessons/never-test-against-production-data.md"
    },
    {
      "n": 18,
      "slug": "local-means-local",
      "part": 3,
      "partSlug": "set-the-boundaries",
      "title": "Local means local",
      "line": "A tool called local reached production, and spent money doing it.",
      "rule": "Check where a tool is pointing before it speaks, and fail loudly if the answer is not what its name promises.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-18",
      "howIDoIt": "Every local tool now asserts its target before it makes any network call.",
      "incident": "A command described as local inherited a managed production address. The run spent about $0.62, took and released a production lease, and stopped before writing a final result.",
      "body": [
        "The fix is a check at the boundary. A local tool accepts only a loopback address such as localhost or 127.0.0.1. A remote address is a hard failure before the first network call.",
        "Environment defaults never get to choose the target silently."
      ],
      "concepts": [],
      "url": "https://chiefofagents.si/lessons/local-means-local",
      "text": "https://chiefofagents.si/lessons/local-means-local.md"
    },
    {
      "n": 19,
      "slug": "the-database-must-be-ready-first",
      "part": 3,
      "partSlug": "set-the-boundaries",
      "title": "The database must be ready first",
      "line": "Code that deploys by itself must never arrive before the tables it expects.",
      "rule": "Database first, code second, and never rewrite a migration that has already run.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-19",
      "howIDoIt": "The order is fixed: additive change, verify real behaviour, database ready, then my merge.",
      "incident": null,
      "body": [
        "New code may expect new tables, columns or permissions. If the code deploys automatically and production does not have them yet, it fails.",
        "So additive database changes are applied and verified before the code that depends on them is merged.",
        "A migration that has been applied is never edited. If it has a defect, a new corrective migration is added. Editing it would make different environments disagree about what the same migration means."
      ],
      "concepts": [
        "what-is-an-additive-migration"
      ],
      "url": "https://chiefofagents.si/lessons/the-database-must-be-ready-first",
      "text": "https://chiefofagents.si/lessons/the-database-must-be-ready-first.md"
    },
    {
      "n": 20,
      "slug": "nobody-grades-their-own-homework",
      "part": 4,
      "partSlug": "judge-the-result",
      "title": "Nobody grades their own homework",
      "line": "A builder's report that it is done is a claim. Someone else decides if it is true.",
      "rule": "Use review that the builder does not control, and make it look at the running product.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-20",
      "howIDoIt": "I use Bugbot for code defects on the complete branch, Thermos for security, structure and maintainability, a vulnerability scanner for dangerous paths and secret leaks, and Gstack for browser checks of the user journey. Those names are my setup today. The rule does not depend on them.",
      "incident": null,
      "body": [
        "Builders never approve their own work. Independent checks look at three things: the diff, how the code behaves when it runs, and what the user experiences.",
        "Different reviewers look for different things. One for defects in the code. One for security, structure and how easy it will be to maintain. One for dangerous paths and leaked secrets. One that walks the user journey in a real browser."
      ],
      "concepts": [
        "what-is-an-evidence-pack",
        "what-is-sub-agent-driven-development"
      ],
      "url": "https://chiefofagents.si/lessons/nobody-grades-their-own-homework",
      "text": "https://chiefofagents.si/lessons/nobody-grades-their-own-homework.md"
    },
    {
      "n": 21,
      "slug": "over-ten-times-the-estimate",
      "part": 4,
      "partSlug": "judge-the-result",
      "title": "Over ten times the estimate",
      "line": "My own count said one thing. The provider's count said another.",
      "rule": "Measure at the boundary where the money is spent, and believe the party that sends the bill.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-21",
      "howIDoIt": "The provider's record is the source of truth for usage. My internal numbers are a guess until they match it.",
      "incident": "I estimated 2,000 to 9,000 units. The provider counted 97,000. One full run of the tests made 238 live requests, and about 17 local runs accounted for roughly 92,000 units.",
      "body": [
        "The provider's export showed live calls that my own estimate had missed. Local test runs had a service key and were making real calls. The automated checks never showed the leak, because their environment had no key at all.",
        "It changed which evidence I trust. The provider's own record now outranks any reconstruction of usage that I build myself. Tests block live provider calls at the client boundary, and every allowed request records the units the provider reports."
      ],
      "concepts": [
        "what-is-a-vacuous-pass"
      ],
      "url": "https://chiefofagents.si/lessons/over-ten-times-the-estimate",
      "text": "https://chiefofagents.si/lessons/over-ten-times-the-estimate.md"
    },
    {
      "n": 22,
      "slug": "no-feature-no-bug",
      "part": 4,
      "partSlug": "judge-the-result",
      "title": "No feature, no bug",
      "line": "The error went away because the feature went away.",
      "rule": "Test for the thing that should happen. Silence is not a result.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-22",
      "howIDoIt": "Tests now assert the intended behaviour, layer by layer, to the result the user sees.",
      "incident": "An agent removed a broken screen so that its checks would pass. Every check went green.",
      "body": [
        "The fix traced the feature through every layer: definition, import, render, state, user action, backend, saving, visible result. The test target became what the user is meant to be able to do, not the absence of an error.",
        "This is why passing checks cannot define correct by themselves. A check can pass after the product has stopped doing what it is for."
      ],
      "concepts": [
        "what-is-a-vacuous-pass"
      ],
      "url": "https://chiefofagents.si/lessons/no-feature-no-bug",
      "text": "https://chiefofagents.si/lessons/no-feature-no-bug.md"
    },
    {
      "n": 23,
      "slug": "new-agent-same-old-mistakes",
      "part": 5,
      "partSlug": "make-it-stick",
      "title": "New agent, same old mistakes",
      "line": "A fresh agent inherits nothing from the last chat.",
      "rule": "Decide where each kind of knowledge lives, and which source wins when two disagree.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-23",
      "howIDoIt": "I use a project wiki, repository rules, Mem0 for memory across sessions, and hooks.",
      "incident": null,
      "body": [
        "Different kinds of knowledge live in different places. A project wiki explains architecture, decisions and history. Repository rules record the failures every agent must read. A memory service gives lasting recall of preferences and lessons across sessions. Hooks inject context and enforce rules automatically, without relying on anyone remembering.",
        "The sources have an order of authority. The code that is running and the project’s written rules outrank summaries, the wiki and remembered context. Memory helps an agent find its feet. It does not overrule the system that actually runs."
      ],
      "concepts": [
        "how-do-ai-agents-remember"
      ],
      "url": "https://chiefofagents.si/lessons/new-agent-same-old-mistakes",
      "text": "https://chiefofagents.si/lessons/new-agent-same-old-mistakes.md"
    },
    {
      "n": 24,
      "slug": "scar-tissue",
      "part": 5,
      "partSlug": "make-it-stick",
      "title": "Scar tissue",
      "line": "The same mistake cannot happen silently twice.",
      "rule": "After every failure ask where the lesson must live so that it cannot be skipped.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-24",
      "howIDoIt": "Important lessons move out of prose and into something that runs, whenever that is possible.",
      "incident": "Three incidents feed it in the talk: the API incident, the deleted screen and the local tool that reached production.",
      "body": [
        "Each serious failure gets a name and a written lesson. Then one question: where must this live?",
        "Architecture and decisions go in the project wiki. Failure patterns every agent should know go in the repository rules. Preferences and lessons go in memory. And anything critical to safety becomes enforcement: a hook, a test, a check in CI, a permission or a database control.",
        "The next agent to approach the same dangerous path is warned with evidence, or blocked. The incident has changed the system, not only my opinion."
      ],
      "concepts": [
        "how-do-ai-agents-remember"
      ],
      "url": "https://chiefofagents.si/lessons/scar-tissue",
      "text": "https://chiefofagents.si/lessons/scar-tissue.md"
    },
    {
      "n": 25,
      "slug": "house-rules",
      "part": 5,
      "partSlug": "make-it-stick",
      "title": "House rules",
      "line": "A skill turns an instruction I keep repeating into something the agent just does.",
      "rule": "When you catch yourself typing the same instruction a third time, package it.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-25",
      "howIDoIt": "Almost every skill I use was made by someone else. The skill library names each maker.",
      "incident": null,
      "body": [
        "Skills package the instructions a team needs again and again. Some carry principles for reasoning and for checking work. \"Fix root causes\" blocks repairs that only hide the symptom. \"Prove it works\" demands evidence you can observe.",
        "No skill replaces judgment. A skill makes a useful behaviour repeatable and easier to audit."
      ],
      "concepts": [
        "how-do-ai-agents-remember"
      ],
      "url": "https://chiefofagents.si/lessons/house-rules",
      "text": "https://chiefofagents.si/lessons/house-rules.md"
    },
    {
      "n": 26,
      "slug": "match-the-model-to-the-task",
      "part": 2,
      "partSlug": "assign-the-work",
      "title": "Match the model to the task",
      "line": "The most capable model does not belong on every task.",
      "rule": "Route by how much it costs to be wrong.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-26",
      "howIDoIt": "Three lanes by risk, and a different lane for the reviewer than for the builder.",
      "incident": null,
      "body": [
        "Before: one premium model on everything. After: mechanical work goes to faster, cheaper models. Ordinary building goes to a capable middle lane. Migrations, security and final review go to the strongest models.",
        "Builders and reviewers use different model lanes, so the same model does not wave through its own assumptions. A long AFK run uses one pinned model to coordinate.",
        "The model names belong to one moment. The routing should follow risk, difficulty and cost."
      ],
      "concepts": [],
      "url": "https://chiefofagents.si/lessons/match-the-model-to-the-task",
      "text": "https://chiefofagents.si/lessons/match-the-model-to-the-task.md"
    },
    {
      "n": 27,
      "slug": "the-bottleneck",
      "part": 6,
      "partSlug": "what-stays-mine",
      "title": "The bottleneck",
      "line": "Me.",
      "rule": "Pick the few decisions you will never hand over, write them down, and delegate the rest.",
      "ruleUrl": "https://chiefofagents.si/one-page#rule-27",
      "howIDoIt": "Agents execute. I judge the result.",
      "incident": null,
      "body": [
        "I remain the final bottleneck by design. Three decisions stay with me: merging to the main branch, changing the production database, and publishing.",
        "Everything else is delegated. Keeping the gates keeps the result mine to answer for.",
        "Your gates may differ. A low-risk internal prototype may need fewer. A product that handles money, personal data or public claims may need more."
      ],
      "concepts": [
        "what-is-a-chief-of-agents",
        "what-is-a-human-gate"
      ],
      "url": "https://chiefofagents.si/lessons/the-bottleneck",
      "text": "https://chiefofagents.si/lessons/the-bottleneck.md"
    }
  ]
}