Chief of Agents

The agent reads the existing context before asking anything. Every blocking question arrives in one decision batch. Each question includes a recommendation and its trade-off. My answers become recorded project decisions.

Define the product, users, outcomes, and boundaries. Record architecture choices and decisions only I approve. Map the project into complete, end-to-end slices. Track changes instead of losing them inside chat.

Horizontal build: nothing works end to end. Vertical slice: one complete journey works.

Start with the smallest real user journey. Touch every layer required to make it work. Test the full journey before adding breadth. Let the first slice expose wrong assumptions.

PRD: the project contract and full slice map. Setup brief: scope, decisions, dependencies, and exit tests. Session-start brief: paste-ready instructions for this slice. Verified state: branch, commit, evidence, blockers, and gates.

Git carries truth between chats. Each slice uses a feature branch, a pull request, recorded state, and a prepared handoff.

In-editor agents work under constant human supervision. Autonomous agents need written scope, state, and boundaries. Longer runs require stronger evidence and stop conditions. Human approval moves from keystrokes to irreversible decisions.

One lead agent owns the slice. Builders implement; checkers verify; one integrator commits. Specialists receive narrow, independent assignments. Isolated worktrees prevent agents from overwriting each other. The lead returns one coherent result.

A loop improves one bounded job through repeated checks. A graph coordinates several jobs, tools, and decisions. Shared state keeps every worker aligned. Edges decide what runs, retries, pauses, or stops. Start with a loop; add a graph when needed.

One loop: plan, build, verify, fix, and pass. Coordinated graph: slice lead, builder, tester, security reviewer, automated checks, evidence pack, and human merge gate. Shared state: scope, diff, evidence, status, budget.

Ask every blocking question before the run begins. Separate reversible choices from human-only decisions. Define permanent fences, budgets, and stop conditions. Open the branch and draft PR before leaving. Require evidence for every completion claim.

Sequence: dependent steps that finish once. Loop: one result improved through repeated verification. Graph: specialists branch, rejoin, retry, and escalate. Choose the simplest shape matching the work.

One decision batch. An AFK contract with scope, permissions, fences, and exit tests. A slice lead coordinates build, test, and evidence. Independent review produces an evidence pack and draft PR. The owner returns at the human merge gate.

Review finishes before the work reaches me. One PR tells one traceable story. Separate complex changes get separate PRs. Checks on the exact proposed commit must be green. I review evidence, then decide what ships.

Code works locally → feature branch → pull request → CI → preview → independent review → human merge → CD → live verification → real users. Database readiness travels on a separate rail and joins before the merge.

Agents can read files, terminal output, and process details. Runtime secret injection does not prevent process output from exposing a value. Documentation stores variable names, never values. Secret scans block accidental exposure.

Agents use an isolated database branch with separate test data and permissions. They can exercise failures without touching real customers. Production has no agent test path.

Local tools accept loopback targets only. A remote URL causes a hard failure before any network call. Environment defaults never choose targets silently.

New code may expect new tables, columns, or permissions. Those changes must exist before code auto-deploys. Never edit applied migrations; add a new correction.

Bugbot: branch-level code defects. Thermos: security, structure, and maintainability. Vulnerability scanner: dangerous paths and secret leaks. Gstack: browser QA and the user journey. Builders never approve their own work.

Provider-reported usage exceeded ten times the highest internal estimate. One full test run made 238 live requests. Automated checks had no provider key, so they did not reproduce the live calls. The fix blocks live calls in tests and records provider-reported usage for allowed requests.

An agent removed a broken interface. Checks passed because the feature was gone. Restore intent through definition, import, render, state, action, backend, persistence, and visible result.

Project wiki: architecture, decisions, and history. Repository rules: failures every agent must read. Mem0: durable preferences and lessons across sessions. Hooks: context injection and automatic enforcement. Live code and governance outrank remembered context.

Name the failure pattern. Write the lesson. Route it to the wiki, repository rules, memory, or enforcement. The future agent is warned with evidence or blocked. The same mistake cannot happen silently.

Skills turn repeated instructions into reusable behavior. Principle skills guide reasoning and verification: fix root causes and check the result the user experiences. Custom skills handle interviews, handoffs, memory, and autonomy.

Mechanical work goes to faster, cheaper models. Builders use a capable middle lane. Migrations, security, and final review use strong models. Builders and reviewers use different lanes. Long AFK runs use one pinned orchestrator.

Me. Merge to the main branch. Production database changes. Publication. Everything else is delegated.