Working with agents
Once by the book.
Once where a check can say no.
An agent writes quickly and drifts quietly. Learn to turn an opinion about the code into a rule a check can enforce, to see what an agent actually reads before it acts, to split work so several agents never fight over one file, and to use all of it without letting your own judgment go soft.
Moving in. 5 of 24 topics have lessons; they're moving over from the old site.
Moving in 5 of 24 topics have lessons, which are moving over from the old site. Planned topics show where the catalog is going.
Enforcement
Rules the agent cannot argue with, and what each one catches.
Enforcement layer
Turn an architecture opinion into a dependency rule, then watch it reject a drifting change
TypeScriptVerification ladder
Climb from type check to human review and see what each rung catches and what slips past
Hooks as protocol
Run the gates before anyone remembers to, and see what a skipped hook lets through
Closing the loop
Let the agent run the gate itself and watch a failure change its next step instead of yours
Architecture as intent
State the shape you want, then check whether it still holds after the agent worked.
Structure over diff
Review what a change did to the structure instead of reading every line the agent wrote
Spec before code
Compare an instruction with a specification and see which one an agent can be checked against
TypeScriptTask shape
See what a unit of agent work needs before it starts: an owner, a boundary, and a done that a check can decide
Testing without agreement
An agent that tests its own code proves agreement, not correctness. Give the tests a truth it did not write.
The closed circle
Watch an agent test its own wrong code to green, then see why agreement is not correctness
Information barrier
Write the tests from the specification with a writer that cannot see the code, so they can catch a bug that already exists
Mutation testing
Break the code on purpose and count the mutants the suite never catches; that number replaces green
Independent oracle
Choose a truth the agent did not write: a reference implementation, a property, or the same cases in another language
What the agent can see and do
The agent works from its context and inside its permissions. Shape both on purpose.
Context engineering
Watch what an agent actually reads before it acts, and why a stale doc is worse than none
Territory maps
Write down who owns which files so parallel agents stop colliding
Generated registries
Generate shared registries from the files themselves so no agent has to edit the hot file
Blast radius
Decide what the agent may touch, run, and send, then see what a permission mode prevents
Running several agents
Split work so agents never share a hot file, and prove the pieces still fit.
Parallel decomposition
Slice a job by ownership rather than size, then watch two agents merge without a conflict
Release gates
Decide what must pass before an agent’s work merges, and whether a person or a check decides
Recorded runs
Record a real agent run once and replay it as evidence, without pretending the model is deterministic
Progress on disk
Keep trackers and audit records in the repo so a session can stop and the next one resumes without guessing
Using AI as a tool
Push into AI as far as it goes, and keep the discipline underneath it strong enough to notice when it is wrong.
Draft directory
Let the agent finish one file in a draft directory, type it into the tree yourself, reading every line, then delete the draft
TypeScriptGoDiagrams first
Ask for the diagram before the code and use it to check that you and the agent mean the same shape
Verify before and after
Run a product workflow that questions an idea before it is built and checks the build against it after
Notes protocol
Learn as a side effect of AI-written work: note each new concept the moment it appears, in a format built for coming back
TypeScript