ai-agents

Raw verification output wrapped in a self-checksum makes agent numbers tamper-evident, while a fail-closed gate rejects slices without anchored review verdicts.

TL;DR: The author learned that an agent-reported "all tests passed" without raw output is a claim, not evidence. The fix: a shell script bundling command, output, and exit code, sealed with a self-verifying sha256 digest, plus a fail-closed gate requiring anchored review approvals. Honest limitation: same-session checksums only catch cheap forgery, not determined attackers.

Four review:* tokens plus a board validator make agent review debt visible, countable, and batchable, while security surfaces never wait in a queue.

TL;DR: Reviewing every tiny slice cost 50-60k subagent tokens per round regardless of diff size, making review the largest session expense. The fix: every done row must carry a review token, enforced by a board validator, with non-security work batched until the queue hits three or the session closes. Security surfaces skip the queue, and tokens make review debt greppable.

Opening eleven .claude/agents files showed me the real constraint is not persona prose: it is the tools, model, and hook fields in six lines of frontmatter.

TL;DR: Eleven subagent files are shaped more like contracts than personas: six lines of frontmatter decide tools, model, and permissions for each role. Scope tools tightly, enforce limits with hooks since rules aren't enforced, and keep every brief self-contained because agents share no context. Delegation costs tokens, so only hand off work worth splitting.

The same agent task produced different results every run. The prompt left decisions to the model; the fix is an explicit work specification.

TL;DR: Same prompt, different outputs usually means the prompt underdefined the work, not that the model is unstable. Treat prompts as work specifications: state objective, context, constraints, output shape, and a verification step. Clear specs make runs converge, checking objective, and cut the expensive corrective iterations, regardless of which model you use.

Adopting the superpowers framework turns a branching naming convention into a real isolation requirement. One worktree per task, enforced by the workflow itself.

TL;DR: The superpowers framework chains coding agents through mandatory stages—brainstorming, git worktrees, planning, TDD, code review—enforced by skills. Worktrees give each task an isolated directory and branch, making the one-branch-per-task rule functional rather than ritual. The overhead pays off only in long autonomous runs; disable telemetry if your data policies are strict.

A commit added 119 lines of execution rules to AGENTS.md. I expected fresh bureaucracy; the opposite: capped interviews, scaled cards, capped iterations.

TL;DR: A 119-line update to the AGENTS file initially looked like heavy process but actually aims to cut friction. It uses lightweight work cards scaled to task size, caps fix attempts at three, and requires verifiable checks before marking done. Clear priorities and scope fences prevent guesswork, silent creep, and wasted context while letting you step away confidently.

I removed the no-coding block from two agent rules files. Instruction rules turned out to be loaded context, not enforcement; hooks do the enforcing.

TL;DR: He deleted the same 26-line no-coding mandate from two repos after his cron flagged the commits as duplicates. The mandate failed because instruction files are just context that fades, not enforced gates, while real blocking needs hooks and verification. He kept lean context layers and now judges per task, doing small edits directly and delegating only complex refactors to Claude.

A 199-line spec for the init-rules skill: layered universal + per-stack packs, CLAUDE.md as an index, and idempotent re-runs the Go generated-code and Copier way.

TL;DR: Starting from a bloated root CLAUDE.md, the author split rules into on-demand, path-specific files instead of one massive doc. The fix became a layered, harness-first skill pack with universal, stack-specific, and scaffold layers plus assert-based self-checks. To make reruns safe, the generator owns all artifacts like Go's generated-code marker, enabling idempotent smart merges that preserve local changes.

A 70/0/0 acceptance run made me think my agent pipeline was deterministic. It was the runner that deserved the credit; temperature 0 was no guarantee.

TL;DR: A flawless 70/0/0 acceptance run looked like proof of a deterministic agent pipeline, but it really validated the harness, not the model. Temperature zero doesn't guarantee reproducibility either; batch invariance and LLM-as-judge studies show outputs and verdicts still flip. Trustworthy results come from test isolation plus byte-level diffs against golden files, never from an agent grading its own work.