01
Restructure the Data, Not the Prompt
The highest-leverage move on an AI process is often not a better model or a smarter prompt. It is changing the data shape so the cheap deterministic operation becomes provably safe.
02
Distrust a Diff That Doesn't Match the Edit
A three-line reword produced a 57-line diff. No error. No test failure. The size of the diff was the only tell.
03
The Competency Demo-Gate
I run a personal AI system that keeps a running record of what it can be trusted to do. Each capability has a level.
04
Single-Writer Machinery for Multi-Session Agentic Coding
The published answer to parallel AI coding sessions is isolation: separate worktrees, sandboxes, containers. This pattern addresses the problem isolation cannot solve: multiple sessions sharing one repository by design.
05
The Gate Blocked Its Own Launcher
122/122 tests green. Adversary passed. The nightly system could not launch because its first write failed its own cleanliness check.
06
The Uniformity Was the Bug
Exactly 12 candidates per source, nothing rejected. A model exercising judgment produces ragged counts. Perfectly uniform output is quota behavior.
07
Tier the Dispatch, Not the Agent
Every agent does judgment work somewhere. The model-tiering question is not which agents can run cheap. It is which dispatches can.
08
Verbatim Means Byte-Verified
Two AI editing passes, two separate documents, one night. Both staged suggestions built on quoted lines that did not exist in the actual text.
09
Per-action approval became per-run, and Agile already had the words for it
I checked how often my approval of an agent's recommendation actually changed it. Almost never. The fix was to stop gating actions and start gating runs, two human touches per run, and it turned out to be a sprint.
10
Autonomy scales with reversibility, not trust
Stop framing agent permissions as which decisions can it make. Reframe it as blast radius times reversibility. Build a clean undo and autonomy falls out for free. You do not negotiate trust, you engineer recoverability.
11
112 tests green, and still broken in production
The build passed its whole suite, deployed clean, and the first real request bounced off the edge before it reached the code. A bypass that makes local testing easy also hides the config that only exists in production.
12
Planning matters more with a smarter model, not less
A better model produces more, faster, and more plausibly, so drift compounds further before a human sees it and is harder to catch in review. The plan is the only target an autonomous run is accountable to.
13
The subagent I built silently never existed
The file was valid, the frontmatter parsed, two sibling agents from the same batch registered fine. This one just was not there, and there was no error. Creating the artifact is not the same as the artifact working.
14
The third option between let-the-AI and do-it-myself is descope
Two units of an autonomous run were risky to run alone. The reflex is binary: run it, or hold it for supervision. The better move was to cut the one piece that created the risk, and keep the rest.
15
Nothing Quietly Forgotten
I built an AI partner that runs across every domain of my work and life. The hard part was never capability. It was memory: making it remember, and making it unable to quietly lie to itself about what it remembers.
16
Rare and Visible
On a one-of-a-kind inventory, two customers can pay for the same item. You cannot make that impossible. So I built it to be rare, and I built it to be loud.
17
The publish flow is the brand
I was two days from building an admin panel for the blog. Worker, auth, token, the whole stack. Then I realized the admin step was already a conversation. The form was solving a problem I didn't have.
18
Right-altitude automation
Build-time API for discovery. Runtime API for delivery. The gate is the discipline.
19
The hybrid memory architecture
Wiki versus database is a false dichotomy. Most production AI memory systems converge to hybrid. The interesting question is how the layers compose at retrieval time.
20
Hard rules earn their cost at the edge
The rule sat unfired for weeks. Then a status-field audit returned the wrong color and the rule fired in real time. Hard rules are mechanism, not policy.
21
Self-red-team as a build pattern
The richest signal about how an AI partner fails isn't in a benchmark. It's in the moment you catch it failing during actual work.
22
Why my AI agent uses Skills instead of monolithic workflows
A capability earns its own Skill when at least two legitimate invokers exist. One invoker is inline territory. Two or more is composition.
23
How to honestly assess your own AI build
An unprompted self-audit at session open. Strong, fragile, five themes, one posture-shift that changes the next month.
24
Why one process doesn't fit every kind of AI Skill
Three authoring patterns coexisting in one project. Each earns its place at a different complexity level.
25
Cheap by default, deep when needed
An AI memory system should auto-load the smallest possible index, then fetch deeper layers only when the task asks. The session-start token load dropped by an order of magnitude when I built the tiers.
26
How to write reference docs that don't rot
A two-layer architecture for reference material: universal constants underneath, per-instance variables on top. Why single-layer docs decay, and how to split them.