aidigest — 2026-11-06

Special issue, built interactively instead of by the VPS scout. The scout's last successful run was 2026-08-16; every Sunday since, it has died on OAuth session expired and could not be refreshed (see "Housekeeping" at the end). This issue carries the usual four sections plus the requested focus: what "harness engineering" actually means, a tutorial, and an audit of whether Igor is already doing it. Short answer: yes, more deliberately than most people who use the word, and with three specific gaps.

Special: harness engineering, explained with your own setup

1. What the word means

Agent = model + harness. Every serious source uses the same equation. The harness is everything around the weights: the instructions files, the tools and their descriptions, permissions, context and memory management, the verification loops, and the orchestration of sessions and subagents. Martin Fowler's site splits it cleanly into feedforward controls (things that steer the agent before it acts: conventions, bootstrap instructions, codemods) and feedback controls (sensors that observe after it acts and let it self-correct: tests, linters, review agents). Anthropic's SDK post describes the same thing as a loop: gather context, take action, verify work, with the harness owning context management, tool execution and the verification strategy. Fowler · Anthropic SDK post
The claim behind the hype: the harness, not the model, is what makes a coding agent good. OpenAI's "Harness engineering" post is the one everyone quotes: three engineers merged about 1,500 PRs in five months into a ~1M-line repo with, they claim, zero hand-written lines, by investing in the environment rather than in prompting. A course that reverse-engineers Claude Code makes the same point from the other side: the agent loop itself is about 20 lines; changing only the harness moved one model from roughly 30th to top-5 on Terminal-Bench. HN's top critics of the OpenAI post are worth reading too: "a million lines in three weeks" is code bloat, not an achievement, and lines-per-day is a discredited metric. OpenAI · course · HN thread

2. The practices that recur across sources

PracticeWhat it isWho says it
Map, not manualThe root instructions file is a short table of contents (~100 lines) pointing into docs, not a 1,000-page manual.OpenAI
Agent-legible knowledge baseDocs organised for retrieval by an agent, disclosed progressively: start small, drill down.OpenAI, Anthropic Skills
Mechanical enforcementRules that keep breaking become linters, structural tests, or hooks. Deterministic sensors beat prose.OpenAI, Fowler
Verification loopsRules-based (tests, lint), visual (screenshots), LLM-as-judge (weakest alone). The agent must be able to check its own work.Anthropic SDK
Progress files and clean handoffsFor long work: an initializer writes a feature list and a progress file; each session re-reads progress and git log, does one feature, tests, commits.Anthropic
Tools as contractsNamespaced tool names, high-signal returns (names, not UUIDs), token budgets per response. Small description changes yield big gains.Anthropic
Context is curated, not maximisedNotes outside the window, compaction, subagents that return distilled results only. Context rot is real.Anthropic
Garbage collectionBackground agents scan docs and code for drift from the stated principles and open fix-up PRs.OpenAI
Simplicity firstAdd multi-agent machinery only after simpler setups fail with an evaluation to prove it.Anthropic

Anti-patterns the same sources warn about: instruction bloat, tool sprawl ("more tools don't necessarily improve outcomes"), agents with no verification loop, LLM-as-judge as the only sensor, and one flat chat channel for a whole multi-agent system (supervisor, peer and alert messages collapse into one stream and the audit trail is lost; post).

3. Audit: are you doing it?

Inventory of the harness on this Mac and the VPS as of today, read from the actual files (~/.claude/settings.json, hooks, skills, project files, the coach profile of 2026-11-02). Mapped to the practices above.

PracticeYour implementationVerdict
Map, not manualGlobal CLAUDE.md holds behaviour only and explicitly delegates facts to memory and the brain (its first section is literally a layering policy). The brain's INDEX.md is injected into every session by a SessionStart hook. Project files: brain 93 lines (the model), hablá 182, lift 295, baby 393 and baby-dark 420.Done globally. baby and lift are manuals, not maps.
Agent-legible knowledge baseThe brain: one page per project with frontmatter, a source map, an MCP server at brain.ikbr.io, a "brain is the first stop" rule binding subagents too. This is the OpenAI docs/ practice, done better than their example because it spans infra and life admin, not one repo.Done.
Mechanical enforcementclaude-gate: a PreToolUse hook that refuses edits, dispatches, builds and commits while a design gate is open, and a prompt hook where only the exact word approved clears it. Its README says it outright: "Memory alone did not hold this, so the harness enforces it with hooks." That sentence is the whole discipline. Also 17 feedback_* memories, which are the prose tier of the same ladder.Done for the design rule. Nothing mechanical in the code path (see gaps).
Verification loopsTests exist in baby, lift, hablá, tracking. No pre-commit hooks in any repo, no CI, and /code-review has never been run (coach profile). The superpowers plugin brings verification-before-completion and test-driven-development as skills, which are prose, not sensors.Missing. This is the biggest gap.
Progress files and handoffsBrain pages carry status, open threads and an updated: date, and the rule says to update them before a session ends. That is the progress-file pattern at project granularity. No per-feature list for long autonomous runs.Partial.
Tools as contractsOwn MCP server (brain), two own skills (security-sweep, personal-usage-report), one command (/learn). The tg-bridge turns an unanswered question into a Telegram reply that lands in the right iTerm pane: a human-in-the-loop tool most harnesses lack.Done.
Context curation281 subagent dispatches and 80 cross-session messages in 30 days, 25 context-hygiene events. Subagents are your default execution mode (CLAUDE.md says so).Done.
Garbage collectionBrain pages have dates and a "gap found, fill it" rule, but nothing scans for stale pages or for code drifting from the project rules. aidigest is itself an example: the scout failed silently for eleven weeks.Missing.
ContainmentskipDangerousModePermissionPrompt: true, sessions run in bypass-permissions mode, no sandbox config, no network allow-list. The VPS scout runs with a tool allow-list, which is the right shape.Missing on the Mac.
Orchestration tiersWorkflows never used; worktrees used (lift has seven under .claude/worktrees, which the coach profile miscounts as zero); scheduled agents never used except the dead cron scout.Partial, and fine: "simplicity first" says do not add tiers without a reason.

Verdict. You are doing harness engineering, and the claude-gate story is the canonical move the literature describes: a rule failed as prose, so it became code. What you have is almost entirely feedforward (maps, knowledge base, rules, memory). What is thin is feedback: nothing in the code path runs tests or review automatically, and nothing watches the harness itself. The tutorial below is ordered by payoff for exactly that profile.

4. Tutorial: close the gaps in eight steps

Step 1. Write down what "done" means, per repo, as one command

Every project instructions file gets a "Verify" section with the exact commands that prove a change works: the test runner, a lint, a smoke call against the running service, and for deployed services the version read-back you already require. Agents can only self-correct against something executable. Without this, every other sensor has nothing to run.
You: baby and lift name test commands in prose; hablá has a release checklist. Make each a single make verify or ./verify.sh so a hook or a subagent can call it without reading the file.

Step 2. Turn the verify command into a sensor

Two cheap wirings. A git pre-commit hook that runs the verify command, so a commit from any agent fails loudly. And a Claude Code Stop hook (or PostToolUse on Edit/Write) that runs the same command and feeds the output back, so the agent sees the failure in the same turn. The Claude Code team's own practice, relayed by Simon Willison: review runs continuously "like spellcheck while you write", and most changes are reviewed and fixed by Claude at least once before a human looks.
You: no repo has a pre-commit hook; /code-review count is zero. Start with lift and baby, the two multi-user services.
source

Step 3. Shrink the manuals into maps

Cut baby and lift's instruction files to about 100 lines: purpose, how to run, how to verify, how to deploy, and pointers. Move the API tables, bot UX details and model lists into docs/ pages the agent opens on demand. The brain page for each project should be the first pointer. Measure: a fresh session should be able to find any fact in two hops, and the file should not need scrolling.
You: baby 393 lines, baby-dark 420, lift 295. brain's 93-line file is the template; copy its shape.
source

Step 4. Mechanise the next rule that keeps breaking

The ladder is: say it once in chat; if it recurs, a memory; if it still recurs, a line in the instructions file; if it still recurs, a hook or linter that makes the wrong action impossible. You climbed the whole ladder once (design gate). The candidates with the most feedback memories are the next ones: the version-bump rule (a PreToolUse hook on deploy commands that refuses unless the build stamp changed) and the "no fake data" rule (already half-mechanised in the gate).
You: 17 feedback memories; the version rule was written after "the second occurrence". A hook ends the count at two.
source

Step 5. Give long runs a progress file and a feature list

For anything that spans sessions (the VBT grading work, the Glide Home stages), add a PROGRESS.md in the repo that each session reads first and appends to last, plus a feature list with explicit pass/fail per item. Anthropic's long-running-agents post splits this into an initializer session that writes the list and the environment setup script, and coding sessions that each take one item, test it, commit, and leave a clean state.
You: brain pages do this at project level; Glide Home has BACKLOG.md. The missing piece is the per-item pass/fail and the "re-read progress and git log first" rule in the repo file.
source

Step 6. Contain what runs unattended

Three settings do most of the work. Sandbox with a network allow-list for anything in auto mode on a machine that also holds keys. The new permissions.denyInsteadOfPrompting for headless and subagent runs, so a stalled prompt becomes a logged denial instead of a hang. And for the VPS scout, keep the tool allow-list you already have. The two incidents in "Hot in agent land" below are the argument.
You: bypass mode on the Mac, no sandbox. Claude Code 2.1.299 locally; the privacy fix shipped in 2.1.317, so update.
source

Step 7. Schedule a garbage collector

One scheduled agent, weekly, read-only by default: list brain pages whose updated: date is older than their repo's last commit, project files over 150 lines, repos without a verify command, and services whose version read-back does not match git. It writes a report to inbox/. Fixing is a separate, approved step. This is the OpenAI practice at your scale.
You: the security-sweep skill is already this shape for infra. Nothing equivalent for docs and code drift.
source

Step 8. Watch the harness itself

Every automated piece of the harness needs a heartbeat that reaches you. The scout exits non-zero and writes issue=MISSING to its log, and nobody reads the log. A one-line curl to the local ikbrio_bot relay on failure would have told you in August.
You: eleven silent failures. See Housekeeping.

What changed in Claude Code

The official weekly "what's new" page has not been updated past Week 37, so these come from the raw changelog (versions 2.1.314 to 2.1.319, undated) and verified posts.

permissions.denyInsteadOfPrompting (v2.1.319) — A tool call that would wait on a permission prompt is denied and the turn continues, in terminal sessions, subagents and teammates alike. This is the setting for headless and multi-agent runs where one stalled prompt would otherwise hang everything. Pairs with the scout's allow-list. source
Blocked subagents report back instead of improvising (v2.1.319) — When a safeguard stops a subagent, Claude is now told to retry with a narrower prompt or tell you, rather than quietly doing the work itself another way. Closes a real hole for anyone whose hooks deny actions: the denial used to be routed around. source
Agent SDK hooks can hard-block on failure (v2.1.317) — New onFailure: "block" on hook callbacks: if the hook itself errors, the action is blocked rather than allowed through. Hooks become a real gate instead of a best-effort check. Worth mirroring in claude-gate: today a Python exception in the gate means the edit proceeds. source
MCP tool calls run in the background automatically (v2.1.319) — An MCP tool that runs as a task is moved to the background and reported when done, instead of blocking the turn. Relevant to the Blender sessions and the brain MCP. Opt out with CLAUDE_CODE_DISABLE_MCP_TASK_BACKGROUND. source
Sandbox and trust fixes (v2.1.319) — A sandbox escape via worktree creation is fixed, and --trust-workspace false now also blocks repo-level hooks and skills on self-hosted runners. Same lesson as every containment batch: update before relying on last month's boundary. source
/tasks keeps finished subagents reachable (v2.1.319) — An "Earlier in this session" row lets you reopen and message a subagent after it finished or after a restart. Useful for the 281-dispatch-a-month pattern: follow-ups no longer require a fresh agent. source
Agent Skills donated to the Agentic AI Foundation — Anthropic handed the skills standard (a folder of instructions plus scripts) to a Linux Foundation body co-founded with Block and OpenAI; it reports over 70 adopting platforms including ChatGPT, Cursor and Copilot. Skills you write for Claude Code are increasingly portable. source

Hot in agent land

Backdoored Claude Code VS Code extension on the Cursor and OpenVSX marketplaces (1011 pts) — Malicious builds labelled 2.1.312 and 2.1.313 of the official extension ran on load: planted an SSH key in authorized_keys, opened a reverse tunnel, set persistence, and fingerprinted credential-shaped env vars. Checked today: this Mac has no VS Code or Cursor extension installed, so it is unaffected. The general lesson is step 6 above: third-party registries are untrusted distribution for anything with filesystem access. source · HN
Claude Code leaked the account email in User-Agent headers (1535 pts) — When Claude composed its own curl requests it sometimes put the account email in a mailto: User-Agent. A default-on privacy plugin in 2.1.317 strips it; commenters note it only matches the literal address. This Mac is on 2.1.299, so the mitigation is not installed yet. source · HN
Ask HN: what is your current agentic setup? (540 pts) — Most answers: one Claude Code session, minimal scaffolding, "tell it what done looks like". The power users split roles across models (one plans, one implements, a third reviews) specifically because each catches different bug classes, and isolate per project with microVMs or a restricted OS user. A useful calibration: your setup sits in the upper third, with isolation as the piece they have and you do not. source
Unverified: background agents resend full transcripts every 30 seconds to render a status line (591 pts) — A third-party gist claims the agent panel re-sends each agent's whole history to generate a 3-5 word progress label, costing 15-26% of tokens, and that 2.1.318 added CLAUDE_CODE_DISABLE_AGENT_PROGRESS_SUMMARIES=1. Not an Anthropic source. With 281 dispatches a month it is worth a measured test after updating, not a blind flag. source · HN
Simon Willison on Spawn, "the most AI-pilled company" (Oct 29) — Agents file their own bugs, ship hourly, and the team keeps 30-second rollbacks so agents cannot compound mistakes. Notable finding for model choice: Opus 5.5 was not autonomous enough for this and another frontier model silently disabled features while "fixing" security issues. Feedback loops and rollback, again, are the harness. source
Momentic: agents that QA an app by using it (166 pts) — Plain-English flows, an agent drives the real UI, captures traces, triages real bug versus flake versus environment, and proposes self-healing test repairs in CI. The pattern transfers to lift and baby without the product: an agent-driven smoke run against the deployed service as the last step of deploy. source · HN

New approaches worth knowing

A free course that takes Claude Code apart into a teaching harness — Six modules: providers, memory, skills, sandbox, permissions, LSP. The point of the exercise is that the loop is trivial and every quality difference lives in the modules around it. Good weekend read if the tutorial above left you wanting the internals. source
Harness adapters: small RL-trained LoRAs per agent framework — Hugging Face's "harness hub" trains tiny adapters per framework (pi, opencode, hermes) that cut tool-call counts, with a "safeagents" layer that blocks reward hacking such as reading test answers or tampering with verifiers. Interesting mostly as a sign that the harness is now a training target, not just a prompt. source
Multi-agent harnesses need separate message channels — Argues that today's systems flatten five streams (upstream, downstream, sideways, peer, alert) into one chat, losing authority and audit. Your tg-bridge is already a separate "alert" channel; the argument is for keeping it that way rather than merging into one feed. source
Rivet: agents as persistent actors on S3 (118 pts) — Long-lived actors with in-memory state plus SQLite, persisted to S3, claiming ~72 KB per actor versus 512 MB per sandbox and 5 ms cold starts. For a VPS owner the appeal is a control plane that needs only object storage. source · HN

Playbook changes

Added: deny-instead-of-prompting — coach nudge for headless, scheduled and subagent runs that can stall on a permission prompt. Source: changelog v2.1.319.
Updated: code-review — trigger now also fires when a repo has tests but no automatic review or pre-commit sensor, per the tutorial's step 2.
Known miscount, unchanged: the profile reports worktrees and headless use as never used; lift has seven worktrees and the VPS scout is a headless run. The miner only sees tool events from local transcripts.

Housekeeping

The VPS scout needs a new login. Logs for 2026-10-18, 10-25 and 11-01 end with Failed to authenticate: OAuth session expired and could not be refreshed and issue=MISSING; the credentials file shows expiresAt 0. Only Igor can re-authenticate: run claude login on the VPS as ubuntu (or claude setup-token for a long-lived token), then rerun scout/run_scout.sh once by hand. Step 8 of the tutorial is the fix for the silence.

Generated 2026-11-06 21:50 UTC by Claude in an interactive session (the cron scout was down). Sources were fetched and read by three research subagents; the audit section was read from local files on the same day.