Second surface-widening pass. 5 parallel Sonnet lanes (E–I), same rules as volume 1 (RESEARCH_top_voices.md): ONE highest-leverage tactical item per voice, real URL + date + verbatim quote, exploit written for THIS system, honest nulls over forced picks, deduped against volume 1. Result: 23 items, 8 nulls/blocked (X session-quota 429s killed Zhang/Murag/Schluntz/Primeagen/Friedman/Linus Lee — flagged for the post-cutoff re-sweep retry).

TOP ACTIONS from volume 2 (ranked)

1. Run Mitchell Hashimoto's model sandwich as A/B #2 (lane E). Fable(plan) → GPT-5.5(code) → Fable(judge), his claim: "few dollars vs typical $50+ full round trips." The blind-judge harness from the GLM A/B (docs/experiments/) re-runs this in an afternoon; both Fable legs ride pxpipe. Outcome updates the routing matrix with measured numbers either way — and theo's GLM result proves these claims are worth testing rather than believing.

2. Install the delegation bookends (lanes F + H). Front: Dan Shipper's "Fable Brief" pre-flight triage template becomes the concrete form of the existing "Sonnet tunes the prompt before any credit-priced Fable run" rule. Back: Alex Albert's final-summary snippet ("write it as a re-grounding, not a continuation… choose clear over short") becomes the required shape of every unattended run's final message. Both are prompt text — cheapest high-leverage items in the sweep.

3. Fix the browser-harness auth-wall gap with Ball's orb recipe (lane E). Dev-only /__dev/log-me-in/<email> + /__dev/preflight readiness endpoints per project driven by browser-harness, plus dev-ports.json for parallel dev-server collisions and .agents/setup/.agents/resume idempotent bootstrap. Turns "auth wall: stop and ask" into a solved class for owned projects.

4. Two loop-catalog adds + one governor (lanes E + H). Crawshaw's Deflaker (cloned devbox, standing flaky-test agent, once-daily phone review) and Horthy's three trigger→loop pairs (ticket→PR, PR→review, PR-comment→fix) as an audit checklist against L1–L10. Governance upgrade from Klaassen: auto-fix gets a deliberately narrow blast radius; everything else lands in a persisted "Decisions for a human" report — the reference implementation for the run contract's escalation field.

5. Design-doctrine guardrails for Mission Control (lanes G + H + I). Carson: no permanent chart surfaces for one-off questions — reusable data-gathering skill + throwaway HTML view instead. Hamel: verification gates force a SECOND pass over the same evidence, never one scan. Cursor's auto-review (Sanger): the graduated in-loop classifier (feedback-not-block, ~7% human escalation) is the v2 architecture for our PreToolUse hook layer when warn/block feels too blunt.

Independent confirmations worth recording: Mollick — Fable ≈2x Opus cost + classifier reroutes "way too often" (external validation of the matrix + the reroute receipts we now ship); Crawshaw + Ball — latency and token-thrash, not sticker price, as the real cheap-model tax (echoes theo, now three voices).

LEDGER E — Yegge / Hashimoto / Crawshaw / Ball / Marsh / Gauthier (sweep 2026-07-07)

Lane E of the top-voices sweep. Method: opencli twitter tweets <user> --limit 30 -f yaml (chronological timeline, not search, to dodge the 429s the master sweep hit) for all 6 voices — all six calls succeeded on the first pass except a follow-up Gauthier tweets call, which 429'd; blog fetches via curl -s [r.jina.ai/](https://r.jina.ai/)<url> for the one long-form post (Thorsten Ball / ampcode.com). t.co links resolved via curl -sIL to get canonical URLs (Beads → github.com/gastownhall/beads, Yegge's essay → steve-yegge.medium.com). Deduped against ~/Developer/claude-mission-control/docs/RESEARCH_top_voices.md — none of these 6 voices appear in that ledger's 21 entries, so there is no overlap to resolve.

1. Steve Yegge (@Steve_Yegge)

• Item: Beads — a git-native "knowledge graph disguised as a lightweight issue tracker" for agentic work, now 650k+ downloads. "Beads is 100% timeless and will work with all models, past and future. It is a knowledge graph of all your work, disguised as a lightweight issue tracker. It is a git ledger of every step your agents will take. It enables agents to tackle larger projects than they could do by themselves. And Beads gives them forensics, the 'why' of your project, that they can join with the what/where/how of your Git commits." — x.com/Steve_Yegge/status/2071351076159356952 (Jun 28, 2026). Repo resolved via t.co redirect: github.com/gastownhall/beads. Follow-up (same day, x.com/Steve_Yegge/status/2071281322988097710): "So we looked at the GitHub numbers, and Beads has over 650k downloads. Beads is still absolutely the best way to work with coding agents, all flavors... I'll be posting a series of tips on how to use Beads to do @bcherny's loops, both small and large."
• Why highest-leverage: this is the one item in his 45-day window that's a shipped, adoptable tool rather than a take — and its stated purpose (git-ledger "forensics," the why joined to git's what/where/how) is close to a word-for-word description of what Mission Control is trying to be, from a different angle (live issue-tracker substrate vs. post-hoc transcript analytics).
• Exploit: spend 30 minutes evaluating bd/Beads as either (a) a complementary ingestion source for Mission Control — if agents start writing decision trails into Beads, that's a structured feed richer than raw JSONL transcripts — or (b) a competitive product to position against, the same way the master ledger tells Mission Control to position against claude agents. Separately, it's a candidate durable substrate for the implementation-notes.md / Deviations doctrine and for gbrain's "wiki memory" gap: a git-committed issue tracker an agent updates as it works, instead of a markdown file it forgets to touch.
• Already-banked? No — not in RESEARCH_top_voices.md. Runner-up (not picked, thinner): his "code smooshing" workflow (Jun 30, x.com/Steve_Yegge/status/2071749142897140005) — kick off a loop/fleet to refactor ~95% of a legacy codebase, but hand-reserve the worst 5% for a personal agent-assisted session, because working the ugliest code yourself alongside an agent is "one of the most satisfying things you can do as a coder."

2. Mitchell Hashimoto (@mitchellh)

• Item: The Fable→GPT-5.5→Fable sandwich, with a cost claim. "I'm having a lot success using Fable xhigh as a planner/architect, using GPT 5.5 xhigh (subscription) as a coder, then Fable xhigh again as a judge. At API pricing, planning+judge costs are in the ~few dollar range compared to typical $50+ full round trips. I've seen some others using dumber/cheaper coders, but GPT 5.5 even at xhigh compared to Fable 5 is very cheap and very fast. And GPT 5.5 is just... really good." — x.com/mitchellh/status/2072715852944957531 (Jul 2, 2026)
• Why highest-leverage: a falsifiable, quantified routing claim (few-dollar plan+judge vs. $50+ full round trip) from a builder known for measuring things, aimed at exactly the axis this user's own CLAUDE.md fleet matrix scores (Fable=cost 1/intelligence 9, Codex=cost 8/intelligence 8) — it argues for using the expensive model only at the two ends of a task (plan, judge) and the cheaper-but-still-strong peer model for the bulk of tokens (coding), rather than any single model end-to-end.
• Exploit: this is a direct, testable variant of the existing "Fable as orchestrator + Sonnet/Codex as executor" doctrine — except it puts Fable (not Opus) at both plan and judge, with Codex/GPT-5.5 as the sole coder in between. Run one real task through it, log actual $/token cost against the current opus-plan+sonnet-execute pattern, and update the routing table with measured numbers (same treatment the ledger already gives theo's GLM correction). Given Fable is credit-metered per this user's own doctrine, this triple-hop pattern should go through pxpipe for the two Fable legs.
• Already-banked? No. Runner-up (not picked): the "1500-line diff" decomposition heuristic (Jun 15, x.com/mitchellh/status/2066645959539556852) — any agent diff over ~1500 lines means the task needs decomposing into atomic, parallelizable, reviewable sub-tasks; a concrete numeric trigger that could sharpen fable-judgment's "next-action under uncertainty" guidance.

3. David Crawshaw (@davidcrawshaw)

• Item: "Deflaker" — a dedicated, persistent devbox running an agent continuously against flaky tests, reviewed asynchronously once a day from a phone. Setup: "let me show you how I deal with flaky tests using exe. First I: ssh exe.dev cp mydevbox-base deflaker. Then I went into Shelley on deflaker and gave it this prompt." — x.com/davidcrawshaw/status/2072363962210173236 (Jul 1, 2026). Payoff, next tweet: "Now once a day, if I have time, I can open deflaker in the exe iOS app and study some build flakes and their proposed fixes. If they're good, I push them." — x.com/davidcrawshaw/status/2072364238262452372
• Why highest-leverage: it's a fully-specified, named loop — a cloned devbox scoped to exactly one recurring problem class (flaky tests), left running continuously, with a fixed human review cadence (once daily) and a fixed human action (push if good) — not a vibe about "agents in the cloud."
• Exploit: catalog this verbatim as a loop-engineering pattern: clone a scoped devbox per recurring problem class (flaky-test triage is the example; skill-audit or dead-code sweeps are others already in this user's stack), give it a standing prompt, and gate output behind a daily human review-and-push step instead of auto-merge. It satisfies loop-engineering's 5-box test out of the gate (recurring, scoped, checkable via a diff-per-flake, capped by "review once a day," human approves the push) — this is a ready-made LOOPS.md catalog entry, not a new invention.
• Already-banked? No. Runner-up (not picked, thinner): his Jul 7 falsifiable claim, "Cost aside, Fable's slowness is a problem... more than half of my prompts avoid Fable just because I am impatient. This is the first time I have chosen speed over intelligence." — x.com/davidcrawshaw/status/2074367272169455838 — a second data point (after Hashimoto and theo) that Fable's raw latency, not its per-token cost, is now the binding constraint on routing to it.

4. Thorsten Ball (@thorstenball)

• Item: "Putting an Agent in an Orb" — the /__dev dev-only endpoint pattern that removes auth as an agent blocker. "Our solution was to add /__dev endpoints... /__dev/log-me-in/ signs the browser in as any local user... /__dev/preflight returns a JSON readiness report: are the secrets configured, is the server healthy, does the selected user have a workspace, a project, credits, an API key, can the CLI connect. When something fails, the agent curls preflight and gets told exactly what's missing instead of guessing... That was truly a game changer." Paired with an idempotent bootstrap contract: .agents/setup (fresh-orb bootstrap script, snapshotted for reuse) and .agents/resume (wake-hook), plus a dev-server skill whose ensure-dev-server.sh reuses a healthy server, restarts a wedged one, or starts fresh, and writes live port assignments to .amp/dev-ports.json so parallel checkouts never collide. — ampcode.com/notes/putting-an-agent-in-an-orb (Jul 2, 2026), amplified at x.com/thorstenball/status/2072726252566270021
• Why highest-leverage: this is a complete, load-bearing engineering recipe (not a take) that solves the exact failure mode browser-harness's own doctrine currently punts on — "Auth wall: redirected to login → stop and ask the user. Don't type credentials from screenshots." Ball's team's answer is: don't fight OAuth with an agent at all, build a dev-only bypass door and a machine-readable readiness check instead.
• Exploit: for any project this user drives end-to-end with browser-harness/automated-e2e, add project-local /__dev/log-me-in/<email> (or CLI/env equivalent) and /__dev/preflight-style JSON readiness endpoints gated to dev/staging builds only — this converts "stop and ask the human" auth walls into something an agent can self-serve past. Steal the .agents/setup / .agents/resume idempotent-bootstrap pair as a template for any project CLAUDE.md that wants to be loop- or worktree-ready, and the dev-ports.json port-registry trick to stop parallel subagents' dev servers from colliding when fan-out spins up several worktrees at once.
• Already-banked? No. Runner-up (not picked): his falsifiable routing claim, "There's a lesson here for everybody who thinks 'I'll just use a cheaper model for certain tasks.' It's very hard to know in advance how smart a model has to be to do a task. If it's not smart enough, it will likely keep trying, using cheaper but more tokens." — x.com/thorstenball/status/2072193095827947727 (Jul 1, 2026, quoting theo's Sonnet-5-cost-more-than-Fable benchmark) — a second independent voice (after theo, already banked) making the same "cheap != cheap" correction to naive cost-tiering.

5. Charlie Marsh (@charliermarsh)

• Item: uv tool install now writes a per-tool uv.lock, specifically to enable uv audit vulnerability scanning of globally-installed CLI tools, not just project deps. "In preview, uv tool install will now write a uv.lock lockfile for every tool, alongside the installation itself" — x.com/charliermarsh/status/2074308209397858736 (Jul 7, 2026) — "We'll use this to enable uv audit to identify vulnerabilities in installed tools" — x.com/charliermarsh/status/2074308449387622812, quoting the original uv audit launch: "Announcing uv audit: native support for vulnerability scanning across your project's dependencies" — x.com/charliermarsh/status/2066954682040267149 (Jun 16, 2026)
• Why highest-leverage: the one shipped, install-time supply-chain-security primitive in his 45-day window, and it closes a gap this user already has an explicit standing rule about (feedback_verify_packages_before_install.md: "before global installs, npm view <name> for repo/desc/maintainers") — that rule is npm-shaped; this gives the Python/uv equivalent for free, retroactively, on every uv tool install.
• Exploit: extend the "verify packages before install" doctrine to Python/uv-based tooling: any global uv tool install <pkg> should be followed by uv audit now that a lockfile exists to audit against, closing the same squatting/supply-chain gap npm's npm view check covers, for any pyenv/uv project (pxpipe, agent-reach's Python deps, etc.).
• Already-banked? No. Honest note: his timeline this window is heavily off-topic/personal (World Cup refereeing, budgeting jokes, "string design") relative to prior windows — the uv.lock-for-tools + uv audit thread is the one clearly tactical item; his other technical tweet (Codex finding a 5-10% Ruff formatter speedup "while I was doing other work," x.com/charliermarsh/status/2071945803313090863, Jun 30) is a Codex endorsement, not a technique of his own, so it was not picked.

6. Paul Gauthier (aider) — NULL, honest

• No tactical item found in the last 45 days (since ~2026-05-24). Evidence gathered: (1) opencli twitter search "aider" --from paulgauthier returned only tweets dated 2024-09 through 2025-06 — over a year stale, no 2026 results surfaced by search; (2) a direct opencli twitter tweets paulgauthier timeline call 429'd (session-quota rate limit) and a retry was not spent given the 25-minute budget; (3) curl -s [r.jina.ai/https://aider.chat/HISTORY.html](https://r.jina.ai/https://aider.chat/HISTORY.html`) (page's own Published Time metadata: 2026-04-25) shows the aider main-branch changelog is still routine model-support churn (Claude 4.5/4.6 aliases, Gemini 3 preview support, GPT-5.1–5.4 variants, o1-pro) — no new technique, benchmark methodology, or workflow, and nothing dated inside the 45-day window at all.
• Best out-of-window item (flagged, not in-window): his running "aider wrote N% of its own code" self-hosting metric and the polyglot-benchmark leaderboard (e.g. Gemini 2.5 Pro 06-05 hitting 83% with 32k thinking tokens, x.com/i/status/1932068596907495579, Jun 2025) — useful as a standing methodology reference (an LLM coding benchmark run against a fixed multi-language task suite) but over a year old and not a new claim this sweep.
• Already-banked? n/a — genuine null, parallel to Geoff Huntley's and Dario Amodei's honest nulls in the master ledger.

Provenance

Sweep 2026-07-07, lane E, single Sonnet pass. Twitter access via opencli twitter tweets <user> --limit 30 -f yaml (chronological per-user timeline, avoided search after learning from the master sweep it 429s under load) for all six voices — all succeeded except a Gauthier tweets retry (429, not re-attempted). One blog fetch via curl -s [r.jina.ai/](https://r.jina.ai/)<url> (ampcode.com/notes/putting-an-agent-in-an-orb) and one via aider.chat/HISTORY.html directly. t.co short links resolved to canonical URLs via curl -sIL. Raw YAML caches: tw_yegge.yaml, tw_mitchellh.yaml, tw_crawshaw.yaml, tw_ball.yaml, tw_marsh.yaml, tw_gauthier.yaml (stale search), tw_gauthier2.yaml (empty, 429) in this scratchpad dir. Deduped against ~/Developer/claude-mission-control/docs/RESEARCH_top_voices.md — none of these 6 voices previously covered.

Research lane F — voices sweep (through 2026-07-07)

Voices: Alex Albert, Barry Zhang, Mahesh Murag, Erik Schluntz (Anthropic) / Alexander Embiricos (OpenAI Codex) / Logan Kilpatrick, Philipp Schmid (Google DeepMind/Gemini).

Method: opencli twitter tweets <user> (OpenCLI backend, browser-login reuse) for user timelines; opencli twitter search/profile to resolve handles and fill gaps; direct image read for a screenshot-only tweet; curl + r.jina.ai for GitHub/blog corroboration; yt-dlp --dump-json for a talk's real upload date. Hit the documented X 429 (session quota) partway through — recovered 5/7 voices via the tweets timeline before quota died; retried after cooldown windows, still 429'd for the last 2 (see nulls). No repo writes, no installs, read-only throughout.

Checked docs/RESEARCH_top_voices.md first — none of these 7 voices appear in that ledger, so no dedupe collisions.

1. Alex Albert (@alexalbert__, Anthropic)

• Item: His "best fix" prompt snippet for Fable 5's tendency to produce jargon-heavy, shorthand-laden final summaries after long unattended agentic runs. Posted as an image (not text) — full verbatim:

  "Terse shorthand is fine between tool calls (that's you thinking out loud, and brevity there is good). Your final summary is different: it's for a reader who didn't see any of that. If you've been working for a while without the user watching (overnight, across many tool calls, since they last spoke), your final message is their first look at any of it. Write it as a re-grounding, not a continuation of your working thread: the outcome first, then the one or two things you need from them, each explained as if new. The vocabulary you built up while working is yours, not theirs; leave it behind unless you re-introduce it. When you write the summary at the end, drop the working shorthand. Write complete sentences. Spell out terms. Don't use arrow chains, hyphen-stacked compounds, or labels you made up earlier. When you mention files, commits, flags, or other identifiers, give each one its own plain-language clause. Open with the outcome: one sentence on what happened or what you found. Then the supporting detail. If you have to choose between short and clear, choose clear." — x.com/alexalbert__/status/2065493229760565758 (Jun 12, 2026). Companion tweet: "Pulled this from our prompting guide which has many more tips for working with Fable" — x.com/alexalbert__/status/2065493242158924031.

• Why highest-leverage: copy-pasteable verbatim, targets exactly the failure mode this user's own doctrine already worries about (agent summaries as re-grounding for a human who saw none of the intermediate work) but gives concrete stylistic rules (no arrow chains, no invented shorthand, one clause per identifier) instead of just "write clearly."
• Exploit: fold this verbatim into the fable-judgment / loop-engineering finish-condition templates as the required shape of any unattended run's final message — it's the missing style-layer underneath the existing "pasted proof" and "summary substitution" rules (Addy Osmani, already banked): pasted proof only works if the surrounding prose doesn't bury it in session-local jargon. Also apply to Mission Control's own forensic reports and to any /goal or scheduled-loop completion message.
• Already-banked? No — new, not in RESEARCH_top_voices.md.

2. Barry Zhang (@barry_zyj, Anthropic agents)

• Item: NULL in-window. His X timeline's most recent post is Dec 10, 2025 (an RT about Claude Skills) — nothing posted in the last 45 days. His biggest recent public artifact, the "Don't Build Agents, Build Skills Instead" talk (co-presented with Mahesh Murag, AI Engineer conf), uploaded Dec 8, 2025 per its own metadata — also outside window.
• Already-banked? n/a. Search for newer content (X search "Barry Zhang agent") also hit the same 429 session-quota wall before it could return results.

3. Mahesh Murag (@maheshmurag, Anthropic, memory & skills PM)

• Item: NULL in-window. Direct timeline pull 429'd (Twitter session-quota rate limit) on every retry across the session; his personal site/GitHub show nothing dated in-window either. The closest signal found was a third party (leopardracer) quoting him from a May 24, 2026 talk/podcast appearance — "memory is the thing that will get us to self-learning agents that evolve and improve based on their own experience" — but that's a secondhand paraphrase, not a primary-source tactical item, and traces back to the same Dec 2025 Skills talk cycle rather than anything new.
• Exploit: none — nothing to act on found this window.
• Already-banked? n/a.

4. Erik Schluntz (@ErikSchluntz, Anthropic)

• Item: NULL in-window. Direct timeline pull 429'd on every retry. His personal blog (erikschluntz.com/posts) is stale since Oct 26, 2025 (a robot-dog hardware post); no 2026 posts. WebSearch surfaced only his 2024 SWE-bench blog-post tweet — well outside window.
• Already-banked? n/a.
• Note: 2, 3, and 4 share the same root cause — the OpenCLI Twitter backend hit its session-quota 429 partway through this lane's run and never recovered within the 25-minute budget (retries at three separate points all failed with the same "retry after cooldown, typically 15-30 min" message). Worth a second pass later specifically on these three handles once the quota resets.

5. Alexander Embiricos (@embirico, OpenAI Codex)

• Item: Codex "Record & Replay" — demonstrate a recurring task once, Codex turns the recording into an inspectable, editable skill. Announcement (OpenAI Devs, quoted by Embiricos): "Show Codex a workflow once. Reuse it as a skill. Record & Replay lets you show Codex a recurring task, like filing an expense report or submitting a time-off request. Codex turns that demo into an inspectable, editable skill. You control when recording starts and stops." Embiricos: "Very excited to ship Record & Replay! Funny story is years ago I bought the domain macros[dot]ai, hoping to build exactly this." — x.com/embirico/status/2067723105272050045 (Jun 18, 2026), quoting x.com/OpenAIDevs/status/2067681320281723113.
• Why highest-leverage: it's the demonstration→skill generation mechanism that the already-banked Brockman/reach_vb "skill-mining audit" prompt (RESEARCH_top_voices.md #6) lacks — that prompt audits after the fact for workflows that should be packaged; Record & Replay is a live capture mechanism that produces the skill artifact directly from doing the task once.
• Exploit: build the Claude Code equivalent manually — when a session does a genuinely repeatable task (a recurring PR-review pattern, a recurring loop-engineering setup), capture the transcript of that successful run and have a subagent distill its tool-call trace directly into a SKILL.md draft, instead of waiting for the monthly audit loop to notice the pattern after N repeats. Pairs directly with Top-5 #4 in the existing ledger (schedule the inverse skill audit) — this gives it an on-the-spot capture mode in addition to the periodic sweep.
• Already-banked? No.

6. Logan Kilpatrick (@OfficialLoganK, Gemini)

• Item: Interactions API hits GA and becomes Google's new default API for orchestrating across models and agents in one interface. "Today we are shipping the Interactions API into GA, our new API designed to let you orchestrate across models and agents in the same interface, and is our new default API going forward. Interactions sets the stage for the new era of Agents :)" — x.com/OfficialLoganK/status/2069115284519346263 (Jun 22, 2026). Philipp Schmid's follow-up (Jun 26) adds the operative detail: "The Interactions API introduced background=True to handle long-running, async agent tasks that exceed standard HTTP timeout limits. We wrote a guide on how to use it, how to reconnect, stream." — x.com/_philschmid/status/2070537421431644432.
• Why highest-leverage: it's a first-party default-API change (not just a model release) that specifically targets the "long-running async agent call that outlives an HTTP timeout" problem — directly relevant to anyone building or auditing cross-provider agent infrastructure.
• Exploit: not a direct Claude Code lever today (no Gemini calls in this user's current fleet), but it's the reference implementation to copy if the pxpipe/GLM-fallback gap noted in ~/.pxpipe/SCOPE.md ever needs a Gemini leg — background=True + reconnect/stream is the pattern to mirror for any custom gateway (pxpipe/headroom-style) that proxies long agent turns across providers. Filed as a "watch, don't build yet" item.
• Already-banked? No.

7. Philipp Schmid (@_philschmid, DeepMind)

• Item: A cross-vendor, installable Agent Skills package manager surface. "We published a skill for Omni Flash so you can bootstrap video editing into your agent: npx skills add google-gemini/gemini-skills --skill gemini-omni-flash-api. The skill covers the core workflows: Text to video, Image references to video, First frame to video, Conversational video editing." — x.com/_philschmid/status/2072057651677257803 (Jun 30, 2026). The repo confirms the framing: google-gemini/gemini-skills — "Skills for the Gemini API, SDK and model/agent interactions" (github.com/google-gemini/gemini-skills). Runner-up from the same account: a talk titled "Don't Ship Skills Without Evals" at AI Engineer, covering "different types [of skill evals], how to build a lightweight eval harness and best practices" — x.com/_philschmid/status/2072357009022943258 (Jul 1, 2026) — content itself not yet published as a blog/video as of this sweep.
• Why highest-leverage: confirms Agent Skills (the SKILL.md folder format Anthropic shipped) is being treated as a cross-vendor standard good enough for Google to publish its own skill packages against, installable via a generic npx skills add <repo> --skill <name> CLI — this is a real, run-today command, not a roadmap item.
• Exploit: npx skills add <github-repo> --skill <name> is worth testing directly against this user's ~/.claude/skills/ — if the installed skill format matches Claude's own SKILL.md contract, it's a way to pull externally-authored (non-Anthropic) skills straight into the catalog, expanding it beyond hand-rolled entries; per the standing "verify packages before install" memory, audit any pulled skill's script contents before trusting it. Separately: watch for Philipp's "Don't Ship Skills Without Evals" content to land — it would give this user's growing skill catalog (currently pruned by fire-count audits) an actual eval harness instead of only usage-based pruning.
• Already-banked? No.

Honest nulls summary

• Barry Zhang, Mahesh Murag, Erik Schluntz — no in-window tactical item found. Root cause for 2/3: OpenCLI Twitter backend hit session-quota 429 and never recovered inside the 25-min budget despite three retries at spaced intervals; for Barry Zhang the timeline pull succeeded but simply had no 2026 activity. Recommend a follow-up pass on these three specifically once the X session quota resets (typically 15-30 min cooldown per the tool's own error message).

Provenance

Sweep 2026-07-07, lane F (Sonnet). opencli twitter tweets/profile/search (OpenCLI backend) for alexalbert__, barry_zyj, embirico, OfficialLoganK, _philschmid (all succeeded); handle-resolution fixes via opencli twitter profile for maheshmurag / ErikSchluntz (correct casing found, but subsequent tweets calls 429'd and never recovered). Direct image read of a screenshot-only tweet (Alex Albert's prompt-snippet graphic) via curl + Read. curl + r.jina.ai for github.com/google-gemini/gemini-skills and www.anthropic.com/engineering (used to rule out a Barry Zhang authorship match on the current featured post — none found). yt-dlp --dump-json for the Zhang/Murag talk's real upload date. Raw YAML caches in this directory: tw_*.yaml, search_*.yaml, thread_embirico_recordreplay.yaml, alexalbert_snippet.jpg.

LEDGER G — Evals/Debugging voices (Hamel Husain, Shreya Shankar, Jason Liu, Omar Khattab, Eugene Yan, Elvis Saravia)

Sweep window: last ~45 days through 2026-07-07. Angle: how to MEASURE and IMPROVE agent quality — evals technique, context-engineering, agent-debugging, falsifiable claims this user (heavy unattended-loop operator, delegated Fable/Sonnet builds, Mission Control transcript forensics) can act on directly.

Method: opencli twitter tweets <handle> (chronological, non-algorithmic) for each voice, opencli twitter thread <id> to pull full reply threads/cards, curl [r.jina.ai/](https://r.jina.ai/)<url> for blog posts. All quotes verbatim from primary-source fetch, all URLs resolved (t.co expanded via curl -sIL).

Deduped against ~/Developer/claude-mission-control/docs/RESEARCH_top_voices.md (21-voice ledger, none of these 6 people appear in it) and RESEARCH_toolbelt.md (Hamel/DSPy appear only as tool endorsements — inspect_ai/evalite — not overlapping with the items below).

1. Hamel Husain (@HamelHusain)

Item: "How to Automate Evals with AI (correctly)" — live session with Shreya Shankar, three named mistakes. "The most important part of the eval workflow is finding issues. Shreya does a live demo of how to steer the AI iteratively to find unknown unknowns... Mistake #1: Asking AI to just 'find the issues' in your data... Mistake #2: Only reviewing your data once... Mistake #3: Treating all apps with the same accuracy bar." — x.com/HamelHusain/status/2074242605634949306 (Jul 6, 2026); video

Why highest-leverage: this is the single most direct rebuttal to "just point an agent at your traces and ask it to find bugs" — the exact failure mode a lazy unattended-verification loop falls into. Names three specific, checkable anti-patterns instead of vague "use AI for evals" advice.

Exploit: audit any Mission Control / no-mistakes review step that asks an LLM to "find issues" in a transcript corpus in one shot — replace with Hamel's shape: (1) iteratively steer the reviewer toward unknown-unknowns rather than accepting the first pass, (2) treat error analysis as a recurring re-review, not a one-time scan (re-run on the same corpus after fixes land, don't just move on), (3) stop applying one accuracy bar to every skill/loop — a /goal finish condition for a security-adjacent loop needs a stricter bar than a cosmetic UI loop. Concretely: the "adversarial-verify" workflows and pasted-proof gates should include a required second review pass, not just one.

Already-banked? No — Hamel does not appear in RESEARCH_top_voices.md or RESEARCH_toolbelt.md.

2. Shreya Shankar (@sh_reya)

Item: Using the Claude Agent SDK's Monitor tool to make agent-generated UI bidirectional. "The most useful thing I talked about was how to use the Monitor tool in the Claude agent sdk (which watches background tasks and reacts to each stdout line as an event) so that user actions in an agent-generated UI actually go back and steer the agent, instead of the UI just being read-only... you just instruct your coding agent to, as part of generating the html artifact, generate JS code to compile user interactions into logs (eg 'user clicked X, user typed Y in this feedback box') and the agent will, thanks to the Monitor tool, subscribe to those logs in real time and adapt the UI or provide new insights. The key novel idea is the UI code is no longer just output, it's the input too." — x.com/sh_reya/status/2074309235685597387 (Jul 7, 2026)

Why highest-leverage: this is a genuinely novel, concrete SDK pattern (not a vibe or a claim) that closes the loop between a generated review/eval UI and the agent that built it — turning HTML artifacts from a one-way report into a live steering surface. Monitor is a real tool this session has direct access to (confirmed present in this environment's deferred-tool list).

Exploit: apply directly to Mission Control / adversarial-verify surfaces: when an agent builds an HTML review artifact (error-analysis grid, failure-taxonomy board, a /goal evidence packet), have it also emit a small JS event logger, then run Monitor on the background task watching that log stream, so a human clicking "this trace is a failure" or typing an annotation directly re-steers the live agent session instead of requiring a fresh prompt. This is a concrete implementation for the generative-ui skill's "level 3: fully generative UI with a feedback channel" case, and a template for building review interfaces (à la Hamel's live demo) that self-improve mid-session.

Already-banked? No — Shreya does not appear in RESEARCH_top_voices.md or RESEARCH_toolbelt.md.

3. Jason Liu (@jxnlco)

Item: "Two kinds of scheduled work" — the decision rule for fresh-thread vs. same-thread automation. "Most automation language is more complicated than the job... Scheduled Tasks create a new thread every time they run. Scheduled Messages use the same existing thread every time they run. That is the whole model... Ask one question: If this ran tomorrow, would it need the earlier conversation? If no, use a Scheduled Task... If yes, use a Scheduled Message... The schedule matters, but it is not the main decision. The main decision is where the useful context should live." — jxnl.co/writing/2026/06/28/two-kinds-of-scheduled-work-in-co (Jun 28, 2026)

His X timeline this window is almost entirely personal/lifestyle content (headshots, hairstyle polls, drumming app); this blog post is his one substantive technical item in the ~45-day window, found via jxnl.co/writing/ rather than X.

Why highest-leverage: a one-question falsifiable test that cuts straight through the ambiguity in the user's own /loop vs /schedule skill boundary — and it's framed as a state-management decision (where does context live), not a scheduling-mechanics decision.

Exploit: fold this decision rule directly into loop-engineering//schedule doctrine: before creating any recurring agent, ask "would tomorrow's run need today's conversation?" — if no, spin a fresh thread/session per run (current default for most scheduled cloud agents); if yes, force the automation to resume the same session/thread (matches this user's existing SendMessage-to-resume pattern for forked agents) rather than re-deriving context from scratch each time. Also steals his companion move: a "make your own loop skill" meta-prompt that asks the missing questions (what to do each time / how often / what change is reportable / when to stop / when to ask for input) only when they're not inferable — a lighter-weight variant of the Definition-of-Ready gate already in CLAUDE.md.

Already-banked? No — Jason Liu does not appear in RESEARCH_top_voices.md or RESEARCH_toolbelt.md.

4. Omar Khattab (@lateinteraction, DSPy)

Item: dspy.RLM (Recursive Language Model) as a shipped, documented DSPy module — context-rot avoidance via code-driven exploration instead of context stuffing. "RLM... is for tasks whose context is too large, too messy, or too unevenly relevant to feed to a model directly. Instead of putting the whole context in the prompt, dspy.RLM hands the model a Python REPL where the context lives as variables, then lets the model write code and call sub-LLMs to explore and manipulate the inputs... Try dspy.RLM when your program is suffering from context rot." Design details: variables + metadata only (name/type/length/preview) surface to the model; llm_query/llm_query_batched give the loop its recursion; max_llm_calls is a hard, per-run budget cap that raises an error fed back to the model on overrun; a separate sub_lm lets a strong planner model delegate cheap extraction to a weaker model. — dspy.ai/diving-deeper/rlm/ (docs page timestamped Jul 5, 2026; DSPy 3.2.1, class marked @experimental)

Omar's own X timeline this window is nearly all retweets (no original technical threads); the highest-leverage item is this documentation of the shipped RLM module, which he originated the research behind (bio: "GEPA, RLMs").

Why highest-leverage: a concrete, falsifiable architecture for the exact problem this user's Mission Control faces — querying a 5.3k-transcript corpus without blowing the context window. It's not "use a bigger context window," it's "keep large data as REPL variables + metadata, let the agent write code to slice it, and hard-cap the number of recursive sub-LLM calls per run" — directly portable outside DSPy.

Exploit: prototype the RLM shape for Mission Control transcript forensics: instead of loading raw JSONL into context, expose transcripts as REPL/file variables with metadata previews, let the analysis agent write code (grep/jq/python) to pull only the slices it needs, and route "read this snippet and summarize" sub-calls to a cheap model (Haiku) while the orchestrating agent stays on Sonnet/Opus — mirrors the existing model-routing doctrine but adds RLM's hard per-run call-budget cap (a concrete mechanism the CLAUDE.md "no cap, no run" rule currently lacks a numeric implementation for). Also: the trajectory field (full {reasoning, code, output} per turn) is a ready-made pattern for a self-inspecting audit trail on any Fable/Sonnet delegated build.

Already-banked? No — Omar Khattab/DSPy does not appear in RESEARCH_top_voices.md (RESEARCH_toolbelt.md mentions inspect_ai endorsed by Hamel, unrelated).

5. Eugene Yan (@eugeneyan)

Item: "Patterns for Building Cybersecurity Evals" — the four-primitive eval-design pattern, generalizable past security. "Before diving into the benchmarks, I think it helps to understand the common pattern they share, largely based on four primitives... A sandboxed target... Inputs that influence task difficulty... Tools... A grader [that gives] immediate feedback [and is] typically deterministic." Plus the graded-partial-credit fix for coarse pass/fail: "to get a more granular picture, we can award partial credit via subtasks that track progress along the attack chain" (find → reproduce → exploit → achieve-goal ladder), and the reward-hacking check: "we can also run automated transcript audits to confirm that the agent actually exploited the vulnerability instead of reward hacking" (ExploitGym used two different frontier models as transcript auditors, hitting 94% agreement across 313 tasks). — eugeneyan.com/writing/cybersecurity-evals/ (published Jun 21, 2026)

Companion, more directly actionable artifact from the same track: an open-sourced Claude Code skill set implementing this loop — "we open-sourced a harness with a skill for each step: /threat-model, /vuln-scan, /triage, /patch. Plus an autonomous find → verify → patch pipeline and isolation sandbox you can /customize. Clone and run /quickstart" — github.com/anthropics/defending-code-reference-harness (Jun 3, 2026); background: claude.com/blog/using-llms-to-secure-source-code.

Why highest-leverage: this is the clearest "how do you actually build an eval harness" template in the whole sweep — four checkable primitives (sandbox, difficulty knobs, tools, deterministic grader) plus two specific fixes for the two most common eval-quality failures (coarse binary grading, and agents reward-hacking the grader). It's domain-general despite the security framing, and there's a working reference implementation to copy the pipeline shape from.

Exploit: use the four-primitive checklist to audit any of this user's own eval/verification setups (crypto-sweep opportunity scoring, Mission Control skill-fire audits, /goal finish conditions): does it have (1) a reproducible sandboxed target state, (2) tunable difficulty/inputs, (3) a fixed toolset, (4) a deterministic grader — and if the grader is coarse pass/fail, add a partial-credit subtask ladder. Directly reusable move: adopt the "two different models cross-audit the transcript for reward-hacking" pattern (94% agreement bar) as the mechanism behind "summary substitution" detection in fable-judgment — an agent's own success claim gets checked by a second, different model reading the raw trajectory, not just accepted. The /threat-model → /vuln-scan → /triage → /patch skill-per-pipeline-step shape is also a clean template for any multi-stage /audit-style skill this user builds next.

Already-banked? No — Eugene Yan does not appear in RESEARCH_top_voices.md or RESEARCH_toolbelt.md.

6. Elvis Saravia / DAIR.AI (@omarsar0)

Item: "Ghost memory" and the evaluate-separately rule for persistent-agent memory. "'Ghost memory' is a real problem with agents. You might have seen the issue where a long-running agent still confidently repeats a user fact that stopped being true weeks ago? New research names the failure 'ghost memory.' Old facts, current facts, and the transition between them all sit in the memory bank at once, get retrieved together, and mislead the answer model. A-TMA is a state-aware overlay that keeps superseded and transition records instead of deleting them, builds evidence packets scoped to the state the query is asking about... Most memory benchmarks report only final QA accuracy, which hides where the error happened... If you build persistent assistants, it's best to evaluate the bank, the retrieval, and the answer separately." Paper: arxiv.org/abs/2607.01935 (LTP benchmark; A-TMA lifts conflict accuracy on Graphiti by 0.240 absolute). — x.com/omarsar0/status/2074121191846261022 (Jul 6, 2026)

Why highest-leverage: a falsifiable eval-methodology fix for exactly the failure mode this user's memory/wiki systems (gbrain, PaperWiki-style setups, long-running loops) are exposed to — stale facts silently outliving their truth window and being retrieved as if current. The actionable part isn't the paper's fix (A-TMA), it's the diagnostic principle: aggregate QA accuracy hides where a memory system failed.

Exploit: when auditing gbrain or any long-running agent's memory correctness, stop measuring only "did the final answer look right" — instrument and score the three layers separately: (1) does the memory bank still contain stale/superseded facts without a supersession marker, (2) does retrieval pull old and current facts together for a query where only one is relevant, (3) does the answer model get misled when both are present. This is a direct upgrade path for the gbrain "sync_freshness" doctor check (currently binary-ish) — split it into a bank-staleness check and a retrieval-conflict check instead of one pass/fail signal. Runner-up from the same voice, lower-confidence: the PaperWiki "LLM Wiki" build (agent-maintained Obsidian vault + qmd index + HTML artifact, updated on a loop) is a close structural cousin of Harrison Chase's already-banked "Wiki Memory" item in RESEARCH_top_voices.md — treat as reinforcement, not a new item.

Already-banked? No — Elvis Saravia does not appear in RESEARCH_top_voices.md or RESEARCH_toolbelt.md. (His PaperWiki item is a partial echo of the already-banked Harrison Chase "Wiki Memory" entry — flagged above, not counted as this voice's primary pick.)

Honest notes

• Jason Liu and Omar Khattab: neither posted an original, tactical item on X itself in the window — Jason's timeline this week is personal/lifestyle, Omar's is almost entirely retweets. Both items above were recovered from their canonical blogs/docs (jxnl.co, dspy.ai) rather than the tweet stream, per the method's blog fallback.
• All six items are net-new adds — none of these six voices appear anywhere in the existing RESEARCH_top_voices.md 21-voice ledger or in RESEARCH_toolbelt.md's tool mentions, so there is no overlap risk to reconcile.

Provenance

Sweep 2026-07-07, lane G. opencli twitter tweets <handle> (chronological, ~30-40 tweets per voice, avoids the 429-prone search endpoint) + opencli twitter thread <id> for full replies/cards; curl -sIL to resolve t.co redirects; curl [r.jina.ai/](https://r.jina.ai/)<url> for jxnl.co, dspy.ai, and eugeneyan.com blog posts. Raw YAML caches in this directory: hamel_tweets.yaml, hamel_evals_thread.yaml, shreya_tweets.yaml, jason_tweets.yaml, jason_search.yaml, omar_tweets.yaml, omar_ms_search.yaml, isaac_tweets.yaml, eugene_tweets.yaml, eugene_vuln_thread.yaml, eugene_eval_thread.yaml, elvis_tweets.yaml.

LEDGER H — Practitioner/production-workflow lane (Dex Horthy, Kieran Klaassen, Ryan Carson, McKay Wrigley, Dan Shipper, Geoffrey Litt)

Sweep window: last 45 days through 2026-07-07. Method: opencli twitter tweets/search/thread (X login-backed, no rate-limit hit this run) + r.jina.ai fetch of linked blog posts/gists/thinkroom docs. Deduped against `/Developer/claude-mission-control/docs/RESEARCH_top_voices.md` (21-voice ledger) — none of these six voices or items appear there.

1. Dex Horthy (@dexhorthy, HumanLayer)

• Item: Incremental software-factory loops — bolt small autonomous loops onto your EXISTING system instead of rebuilding the pipeline. "The biggest mistake i see people make when they decide to go 'ai first' or 'agent native' is they think they have to rethink the entire software factory from scratch... a much better approach is to incrementally layer small autonomous loops onto your existing system: ticket gets filed with a specific label or assignee? have an agent try to implement it to PR. new PR? have an agent review it against code standards and a review checklist. comment on a PR? have the coding agent push a new commit addressing the feedback." — x.com/dexhorthy/status/2071649145077874983 (Jun 29, 2026)
• Why highest-leverage: a concrete anti-pattern warning (all-or-nothing factory rebuilds lose contact with the problem space) plus three copy-pasteable trigger→loop pairs that compose into a factory without a rewrite.
• Exploit: audit the armed loop roster (L1–L10) against his three triggers — confirm a labeled-ticket→PR loop, a new-PR→review-checklist loop, and a PR-comment→fix-commit loop each exist as a named, capped loop (not folded into one mega-loop). Where one of the three is missing, that's the next loop-engineering addition, scoped exactly as small as his tweet describes — resist the urge to design a bigger "factory" around it.
• Already-banked? No — distinct from the banked Dex items (VM-per-agent, /goal loops).

2. Kieran Klaassen (@kieranklaassen, Cora / compound engineering plugin)

• Item: /ce-dogfood — an autonomous QA skill that dogfoods the active branch end-to-end in a real browser, with a fix-loop governor and a persistent, resumable report. From the linked write-up: "/ce-dogfood acts as a QA engineer who dogfoods the active branch: understand every change, test every change in a real browser as a user would, and fix what breaks, autonomously, until the branch is ready." Key mechanics: diff-scoped (never whole-app, refuses to run on trunk), drives a real browser through a single shell CLI (agent-browser, not MCP), maps user flows before deriving a scenario matrix ("the email rule" — an email sending isn't a pass, the click-through to the right thread is), judges every scenario twice (functional pass/fail + a seeded product-persona re-read for "paper cuts"), and gates auto-fixes: each fix ships with a regression test designed to fail-before/pass-after, one logical fix per commit, and anything outside a narrow blast radius gets escalated to a "Decisions for a human" report section instead of attempted. Report persists to docs/dogfood-reports/<date>-<branch>-dogfood.md so a killed session resumes from disk. — tweet: x.com/kieranklaassen/status/2073522269964693915 (Jul 4, 2026); full mechanics: thinkroom.kieranklaassen.com/d/njrS5TJhis ("Closing the Verification Loop")
• Why highest-leverage: a fully specified, shipped verification-loop skill — not a prompt tip — with an explicit governor for what an agent is allowed to auto-fix vs. must escalate, and a durable-report design built for interruption.
• Exploit: direct upgrade path for automated-e2e and browser-harness here. Two things to steal verbatim: (1) the flows-before-matrix rule ("an email sends" is not a pass — walk the flow to its true end state) as a checklist addition to any browser-harness QA pass; (2) the fix-loop governor (auto-fix only within a narrow blast radius; everything else becomes a "Blocked (human decision)" row in a persisted report, never a silent guess) as the missing escalation/stopping-condition detail the Osmani run-contract gate (already flagged in the banked doc) is asking for — this is a working reference implementation of exactly that gap.
• Already-banked? No — first appearance of Kieran/Cora/compound-engineering in either ledger.

3. Ryan Carson (@ryancarson, Untangle)

• Item: Kill the dashboard habit — replace built dashboards with agent-generated, throwaway, on-demand HTML. "Every time you think you need a dashboard to look at data, stop yourself. Do this instead: 1. Ask your agent to make sure that you have all the data to analyze something actually stored in the database. 2. Ask your agent to write a skill to gather that data. 3. Ask your agent to do the analysis and create a temp and throw-away HTML dashboard to answer the question(s) that you have. In my experience, every dashboard that I've created gets less and less use over time and decays. It's much better to make sure your agent can get the data you need and answer the questions you have, on-demand." — x.com/ryancarson/status/2071535177126277239 (Jun 29, 2026; went viral, self-quoted Jun 30)
• Why highest-leverage: a falsifiable claim about dashboard decay plus a concrete 3-step substitute (durable skill for data-gathering, disposable HTML for the view) that converts a standing UI-maintenance burden into a one-shot artifact.
• Exploit: directly cuts against any temptation to grow Mission Control into more permanent chart/dashboard surfaces for one-off questions (context-tax spikes, fire-count audits, ad hoc cost breakdowns) — for those, the move is a small reusable "gather the data" skill plus a disposable HTML render per question, not a new persisted dashboard page. Keep the durable investment in the data-gathering skill, not the view. Complements (doesn't duplicate) the banked "HTML is the new markdown" doctrine line — his angle is specifically anti-permanence for dashboards, not output format in general.
• Already-banked? No.

4. McKay Wrigley (@mckaywrigley)

• Item: NULL — honest. Pulled his tweets timeline (40) plus a targeted from:mckaywrigley since:2026-05-24 search (15 results) covering Jun 13–Jul 4. Content in-window is entirely hot takes/vibes/replies (Fable "magic model smell," Cursor-anniversary nostalgia, political-adjacent one-liners) and a single reaction meme image (robot-hand/Sistine-Chapel touch, no caption) — no workflow, prompt technique, or shipped artifact. His one substantive AI-workflow post in the broader timeline (an Apr 24 "random ai thoughts" model-comparison roundup) falls outside the 45-day window and is vibes/opinion, not tactical, even if included.
• Already-banked? n/a — no item to compare.

5. Dan Shipper (@danshipper, Every)

• Item: Every's "Claude Fable 5 Prompt Library" — 13 copy-ready prompts (built from Mike Krieger's/Anthropic Labs' own Fable usage + Every's internal workflows), anchored by two reusable templates: a pre-Fable discovery prompt that has a cheaper model triage your own context and score candidates 1–5 on "multi-source context, delegation fit, judgment required, clear finish line, leverage, Fable fit" before recommending escalation, and "The Fable Brief" — a structured handoff (problem, desired outcome, sources, constraints, explicit "pause only for a destructive/irreversible action, a real scope change, or human-only information," and a mandatory pre-report audit: "Before reporting progress or completion, audit every claim against a tool result from this session. If something is not verified, say so plainly."). Dan re-surfaced/promoted it Jul 3: "Get our Fable 5 prompt lirbrary and head to the beach" — x.com/danshipper/status/2073077325520838993 (Jul 3, 2026); source article (published Jun 10, still being actively promoted in-window): every.to/p/claude-fable-5-prompt-library
• Why highest-leverage: it's a shipped, tested prompt pack from the team that runs Fable/Claude Code hardest in production (Every), not a one-off tip — and the discovery prompt is a ready-made instantiation of exactly the "should this go to Fable" triage the user's own routing table does by hand.
• Exploit: (1) the discovery prompt is a drop-in pre-flight check before any pxpipe/Fable dispatch — run it against a task's context to force an explicit 1–5 score on delegation-fit/judgment/leverage before paying Fable-tier cost, rather than eyeballing it; (2) "audit every claim against a tool result from this session; if unverified, say so plainly" is a tighter one-line phrasing of the already-noted "summary substitution" anti-pattern (Osmani, banked) — worth pasting verbatim into fable-judgment's evidence-packet rule since it's phrased as an instruction an agent can literally follow, not just a review heuristic.
• Already-banked? No — first appearance of Dan Shipper/Every in either ledger.

6. Geoffrey Litt (@geoffreylitt, Notion)

• Item: explain-diff — a shipped Claude Code skill (two variants: HTML output, Notion-page output) that turns a code diff/branch/PR into a self-contained, interactive teaching artifact: background section (deep-enough for a beginner, skippable for experts), an "intuition" section with toy-data examples and diagrams, a high-level code walkthrough, and — the distinguishing piece — a 5-question interactive multiple-choice quiz that only someone who actually understood the change could pass, with per-click correct/incorrect feedback. From the skill file itself: "Come up with five questions that test the reader's knowledge of this PR... difficult enough that you actually need to understand the substance of the PR to answer them, but not gotchas. The goal is to help the reader make sure that they've actually understood." Presented as tweet 23/36 of his AIE-talk thread: "OK, so that's explain-diff. Here's the skill if you want it: two variants that output either HTML or Notion page." — x.com/geoffreylitt/status/2072522312856039461 (Jul 2, 2026); skill source: gist.github.com/geoffreylitt/a29df1b5f9865506e8952488eac3d52 talk write-up: geoffreylitt.com/2026/07/02/understanding-is-the-new-bottlen
• Why highest-leverage: it's a complete, pasteable skill file (not just a prompting idea) whose novel move — a graded comprehension quiz, not just an explanation — is a falsifiable check that the human actually understood the agent's diff, which a passive HTML/markdown writeup can't give you.
• Exploit: install as a literal skill for post-PR review sessions (self, or before approving a subagent's fan-out diff) — stronger than the already-banked delba "walk me through architectural changes" prompt because it forces active recall via the quiz instead of passive reading. Natural fit for the /code-review flow's pre-diff step: run explain-diff first, take the quiz, only then read the raw diff. Distinct from Zara Zhang's "codebase-to-course" skill that a reply surfaced under the same thread (github.com/zarazhangrui/codebase-to-course, a whole-codebase course generator) — noted but not the primary pick since it's a third party's reply, not Geoffrey's own artifact.
• Already-banked? No — the banked delba item covers the same problem space (architecture-first review) but is a prompt, not a skill; this is additive, not a duplicate.

Honest nulls

• McKay Wrigley — 45-day window is vibes/hot-takes/replies only; no tactical item found via tweets-timeline (40) or targeted date-filtered search (15). See item 4 above for detail.

Provenance

opencli twitter tweets <user> --limit 40 -f yaml per voice (dexhorthy, kieranklaassen, ryancarson, mckaywrigley, danshipper, geoffreylitt) — no 429s this run. Supplemented with opencli twitter search "from:mckaywrigley since:2026-05-24" --product live (McKay's default timeline skewed old/pinned-like) and opencli twitter thread <id> for Geoffrey Litt's 36-tweet AIE thread (thread endpoint returned replies-only; full thread reconstructed from his own tweets timeline, which included the numbered 1/–36/ sequence). Linked artifacts fetched directly: r.jina.ai for thinkroom.kieranklaassen.com and every.to; raw gist content via gist.githubusercontent.com/.../raw/; t.co redirects resolved via curl -sIL. Raw caches in this directory: tw_dexhorthy.yaml, tw_kieranklaassen.yaml, tw_ryancarson.yaml, tw_mckaywrigley.yaml, search_mckay.yaml, tw_danshipper.yaml, tw_geoffreylitt.yaml, thread_geoffreylitt.yaml, mckay_jul4.jpg.

LEDGER I — Cursor voices, Mollick, Primeagen, Friedman, Lee (sweep 2026-07-07)

Lane angle: competitor-product insights worth stealing (Cursor's agent features), research-backed usage findings (Mollick), and contrarian/skeptic evidence that would falsify something in this user's doctrine. Deduped against ~/Developer/claude-mission-control/docs/RESEARCH_top_voices.md — no repeats found with any item below.

Method note up front: X (via opencli twitter / OpenCLI backend, and the bird legacy CLI as a same-session fallback) hit a hard 429 session quota on both UserTweets and SearchTimeline endpoints partway through this run and never recovered within the 25-minute budget (retries spaced ~5 min apart across ~20 min all failed; bird shares the same browser cookies/account so it hit the identical quota; anonymous r.jina.ai access to x.com was separately blocked domain-wide "due to previous abuse" until 07:54 UTC). The TweetDetail (single-tweet/thread) endpoint stayed alive throughout and was used to pull real, dated, verbatim tweets wherever a specific status ID could be sourced. Cursor's own blog (cursor.com/blog, via r.jina.ai) was fully reachable and is the primary source for the Aman Sanger and Lee Robinson items below, cross-confirmed against tweets that did load before the quota hit.

1. Aman Sanger (@amanrsanger, Cursor co-founder)

• Item: Cursor's "Auto-review" autonomy classifier — a small, fast, agentic classifier that sits inline in the tool-call path and governs agent autonomy as a continuum instead of a binary allow/block. "This week we launched Auto-review, which makes decisions around agent autonomy behave more like a dial than a switch... We determine where an action sits along that continuum with a specialized classifier agent that reviews actions in context before they run." It can inspect the workspace (ReadFile/Grep/Glob/ListDir) before deciding, runs in the same RPC stream as the parent agent (no added-latency side endpoint), and on block it returns an explanation to the parent agent rather than immediately interrupting the user — "When it blocks an action, it returns an explanation to the parent agent, and the parent agent can often use that feedback to choose a safer path without interrupting the user." Measured result: the classifier blocks ~4% of actions but only ~7% of total chats in Auto-review mode see even one user interruption, versus ~40% of actions blocked at some enterprise customers running static allowlists. — cursor.com/blog/agent-autonomy-auto-review (Jun 11, 2026)
• Why highest-leverage: this is Cursor's actual production answer to the exact failure mode this user's own doctrine names but doesn't yet solve mechanically: the "classifier tax" line in CLAUDE.md currently just says security-phrased prompts get silently rerouted/refused — Cursor's writeup is the missing architecture for a graduated, in-loop, feedback-giving classifier instead of a blunt reroute-or-refuse.
• Exploit: prototype a lightweight "auto-review" pre-check as a PreToolUse hook or subagent-wrapper for Mission Control fan-outs: before a subagent's tool call executes, a cheap classifier model (Haiku-tier) judges risk-in-context (not just keyword-matching for "security"/"exploit"), and on a block, it returns structured feedback to the calling agent to retry narrower — instead of the current behavior (the safety classifier silently rerouting the whole subagent, forcing the "send security-adjacent work to Opus yourself from the start" workaround). Directly upgrades the Definition-of-Ready gate's "escalation" field (from the Osmani ledger entry already banked) with a concrete implementation, and gives a measurable target: aim for <10% of runs needing a human interrupt, matching Cursor's 7% figure.
• Already-banked? No — distinct from Osmani's run-contract entry (#13 in the source ledger) and from the Boris Cherny background-agents entry (#2); this is the risk-classifier mechanism itself, not the autonomy-contract or scheduling layer.

2. Lee Robinson (@leerob, Cursor — Model behavior)

• Item: His own field log of one day driving five parallel background/cloud agents between meetings, ending with a routing-relevant cost note. "Cursor (and coding agents generally) still blows my mind daily. Just today: 1. I shipped a new landing page. I gave a 10min voice note to Cursor, left to go eat dinner, and came back to a 90% finished version... 2. Had Cursor dig through Search Console and Semrush with computer use, researched places we could improve SEO, and then merged 3 PRs with fixes. 3. Used the Supabase MCP to pull thousands of emails from the Compile waitlist, had it research them with web search based on ideal fit for the event, and got back a CSV with the top people to invite and why... Most of these were running in the cloud as I was between meetings, just humming away in the background... (P.S. if you extrapolated my usage today, I'd still be on the $200/mo plan)" — x.com/leerob/status/2063055479106879562 (Jun 6, 2026)
• Why highest-leverage: it's a concrete, varied catalog of what "walk-away autonomy" actually looks like in practice for a power user (voice-note → agent → merge; MCP-driven data pull → research → CSV artifact; computer-use log-digging), not a feature announcement — five reusable task shapes for this user's own /goal and loop roster, plus a real cost anchor (heavy multi-agent daily use still fits a flat $200/mo plan, i.e., token cost for this class of task is not the bottleneck, attention/review is).
• Exploit: mine his five task shapes directly into the loop-engineering catalog as concrete loop templates (voice-memo-to-PR, computer-use-SEO-audit, MCP-pull-then-research-then-CSV, internal-tool-scaffold, multi-agent-shopping-research) — each is already goal/scope/stopping-condition-shaped, satisfying the Definition-of-Ready gate with almost no rewriting. Secondary: his Jun 11 tweet on "autoinstall" (agents auto-configuring their own dev/RL environments so "the better the model gets, the better it gets at creating the conditions to train its successor" — x.com/leerob/status/2065069068722241729) is a stealable pattern for scheduled loops that currently need manual environment bootstrap.
• Already-banked? No.

3. Ethan Mollick (@emollick / oneusefulthing.org)

• Item: Hard operational numbers on Fable (Mythos-class) vs. Opus from hands-on testing, including the exact failure mode this user's CLAUDE.md already flags. "Fable is twice as expensive as Opus, and it burns through tokens at a rate that suggests the answer to how much it costs in production is 'a lot,' though its clever delegation to cheaper models may lower the real price considerably. The guardrails for Fable also trip at the faintest hint of a security problem, defaulting to the less powerful Claude 4.8 Opus, and it happens way too often." Same post: a 9.5-hour autonomous run built a complete human/AI-judgment-calibration tool ("Concord") from one 19-page design doc, and a separate isochrone-map test showed Fable spinning up its own cheaper-model (Sonnet) sub-agents for research while coding in parallel. — oneusefulthing.org/p/what-it-feels-like-to-work-with-mythos (Jun 9, 2026)
• Why highest-leverage: this is independent, hands-on confirmation (not vendor marketing) of two load-bearing assumptions in this user's own routing table — Fable's cost premium over Opus, and the classifier-tax fallback-to-Opus behavior on anything security-adjacent — with a number attached ("way too often") that argues the fallback rate may be higher than the doctrine assumes.
• Exploit: (1) treat "2x Opus cost" as an external sanity check on the CLAUDE.md cost score for fable-5 (currently "1" — cheapest — which only holds through pxpipe compression; uncompressed or interactive Fable use is expensive, reinforcing the existing "ALWAYS through pxpipe" rule rather than contradicting it); (2) the "trips at the faintest hint... way too often" line is direct evidence for tightening the "Classifier tax" doctrine line from "send security-adjacent work to Opus yourself" (reactive) to "assume any Fable run touching auth/crypto/exploit-adjacent code will silently downgrade to Opus, so don't route those to Fable at all, even via pxpipe" (proactive). Runner-up, same lane, different post: his Jun 30 "twilight of the chatbots" finding that in Claude Code usage data, "What actually mattered was not the profession of the user, but their expertise. The more domain experience someone had, the more successful they were in using Claude Code in that domain" (https://www.oneusefulthing.org/p/the-twilight-of-the-chatbots) — a falsifiable nuance on "taste >= 7" gating: the same model produces worse output for a non-expert reviewer regardless of model tier, arguing for a "does a domain expert exist in this loop" check alongside the model-tier gate.
• Already-banked? No.

4. ThePrimeagen (@ThePrimeagen) — BLOCKED, honest partial

• Status: Could not retrieve any verified in-window (~May 24–Jul 7) tweet. opencli twitter tweets/search and the bird CLI (same X account/session cookies) both hit 429 session quota on every retry across the full run; anonymous r.jina.ai fetches of x.com profile pages were separately blocked ("Anonymous access to domain x.com blocked... due to previous abuse," lifting ~07:54 UTC, after this run's budget). WebSearch surfaced only out-of-window material with real IDs verified via the still-live TweetDetail endpoint: an Apr 26, 2026 quote-tweet of Dario Amodei's "coding is going away first" (https://x.com/ThePrimeagen/status/2048509229091233928) and an Apr 13, 2026 tweet, "I am slowly coming around to AI assisted programming. I am genuinely trying to codify every rule about programming that I have and using that + several stages to build out small changes" (https://x.com/ThePrimeagen/status/2043861800819761382) — both ~6+ weeks outside the window, so not used as the ledger item.
• Why this matters for the mission: his lane here was specifically the falsification/skeptic angle, so an honest null is worth flagging rather than forcing a stale item — the Apr 13 "coming around to AI assisted programming, codifying every rule" tweet is nonetheless a legitimate, on-target skeptic-softening data point if a future pass wants to re-verify it's still his current position.
• Already-banked? n/a — no item claimed.

5. Nat Friedman (@natfriedman, Meta Superintelligence Labs) — BLOCKED, honest partial

• Status: Same rate-limit wall as above; no verified in-window primary-source tweet retrieved. Nearest verified-by-TweetDetail item is a May 17, 2026 secondhand report (7 days outside the window), Polymarket quoting him: "Former GitHub CEO Nat Friedman says his OpenClaw AI agent watches him through a home camera to make sure he drinks enough water" (https://x.com/Polymarket/status/2055991220975845696, confirmed real/dated via TweetDetail) — amusing and on-theme (proactive/ambient personal agent pattern) but secondhand, out-of-window, and not from his own account, so not used as the ledger item. WebSearch otherwise only surfaced his standing role (VP Product, Meta Superintelligence Labs) and older/background material.
• Already-banked? n/a — no item claimed.

6. Linus Lee (@thesephist / thesephist.com) — BLOCKED, honest partial

• Status: Same X wall. His blog (thesephist.com/posts) has not published since Aug 17, 2025 ("Compose tasks, not implementations") — confirmed via direct fetch of the full posts index, so no blog item exists in-window either. The one verified in-window signal is a talk, not a tweet or post: he spoke at Cursor's inaugural "Compile" conference (Jun 16, 2026, SF) on "Notational Intelligence" — how the way we write ideas down shapes thinking, and how models might invent new notations — video at

Not transcribed within this run's budget, so no verbatim quote is available; flagging the existence and date only, not claiming it as a scored ledger item.

• Why flag anyway: if a future pass has budget to transcribe the talk, "notational intelligence" (new notations that are more expressive for a model to write in than prose/markdown/code) is thematically adjacent to the already-banked "HTML is the new markdown" convergence (Karpathy/Thariq/delba/IndyDevDan) — worth checking whether Lee's argument extends or complicates that doctrine line.
• Already-banked? n/a — no item claimed.

Honest nulls / partial coverage summary

• 3 of 6 voices fully delivered: Aman Sanger, Lee Robinson, Ethan Mollick — all with verbatim, dated, URL-cited items, all new (not in the existing 21-voice ledger).
• 3 of 6 voices blocked by a platform-side rate limit that persisted for the entire ~25-minute budget across every available channel (OpenCLI, bird CLI on the same account, anonymous Jina proxy to x.com): ThePrimeagen, Nat Friedman, Linus Lee. Each entry above documents the closest verified-real, dated material found and why it wasn't used (wrong window or secondhand), rather than fabricating a fit.
• Recommendation: re-run these 3 in a fresh agent-reach session after the stated 15–30 min X cooldown (or after 07:54 UTC for the Jina anonymous block) — the "tweets" and "search" endpoints, and the x.com domain block, should be clear by then.

Provenance

Sweep 2026-07-07, single lane (Lane I). opencli twitter tweets/search (OpenCLI backend) for Aman Sanger and Lee Robinson before the 429; opencli twitter thread (TweetDetail, stayed live throughout) for spot-verifying specific status IDs; bird CLI attempted as a fallback for the blocked 3 voices (failed — shared account cookies, same quota); curl + r.jina.ai for cursor.com/blog (agent-autonomy-auto-review, cloud-agent-lessons, cursorbench) and oneusefulthing.org (twilight-of-the-chatbots, what-it-feels-like-to-work-with-mythos); WebSearch as a last-resort discovery tool for the 3 blocked voices (did not yield in-window primary-source quotes). Deduped against ~/Developer/claude-mission-control/docs/RESEARCH_top_voices.md.

CORRECTIONS PASS (2026-07-07 eve)

Two fixes to the top-voices sweep, run against the live system rather than against the research docs themselves.

Part A — Audit: were the volume-1 "second-best" picks actually justified?

The bug: the original sweep sometimes conflated "I recorded this idea in a RESEARCH_*.md file" with "this is actually running on the machine," and dropped a voice's genuine #1 pick to second-best on that false premise. Recorded is not adopted.

Method: for each of the 10 flagged entries, checked the live system — ~/.claude/CLAUDE.md, ~/.claude/skills/*/SKILL.md and LOOPS.md, ~/.claude/commands/, ~/.claude/plugins/installed_plugins.json — for a concrete, checkable artifact (an armed loop, a literal CLAUDE.md line, an installed skill/command), not just a mention.

Result: 1 of 10 was wrongly skipped. The other 9 turned out to be genuinely, checkably adopted — a previous session evidently acted on volume 1's own "TOP-5 — act on these now" list (the HTML-doctrine line, the Osmani run-contract fields, the GLM A/B, the armed wiki-compile loop are all now live in the actual files), which is why most of the "banked" claims hold up under a live-system check. The one miss is the one the task flagged as known-bad going in.

shadcn (@shadcn) — RECLAIMED — was wrongly skipped

• Item: /improve — a shipped, installable Agent Skill (npx skills add shadcn/improve, github.com/shadcn/improve) that separates audit/planning from execution. It fans out parallel subagents across nine audit categories (correctness, security, perf, test coverage, tech debt, deps/migrations, DX, docs, and "direction" — feature suggestions that must cite repo evidence), has the advisor model re-check every subagent finding itself before surfacing anything (drops false positives, records rejections so they don't recur), then writes one self-contained plan per selected finding into plans/ — exact file paths, current-state code excerpts, the repo's own verified test/lint commands as machine-checkable verification gates, and explicit STOP conditions. The skill never edits source itself. Launch, verbatim: "Introducing /improve: use your most capable model to audit your codebase and write plans for cheaper models to execute later. Studies your code, figures out bugs, perf, tech debt, missing tests, what to build and writes plans any agent can run." — x.com/i/status/2064671802509410806 (Jun 10, 2026, 6.4k likes). Urgency framing three days later, after a frontier model got pulled: "In light of what happened, I'm doubling down on skills like /improve. A frontier model got pulled. If it happened once, it's gonna happen again. Fable today. 4.9 tomorrow or maybe gpt 6 one day. So, treat intelligence as borrowed. Drain intelligence when it's available. Build a catalog of plans today. Then implement later with a cheaper, open source, or a model you control. Build the backlog now." — x.com/i/status/2065826989769163068 (Jun 13, 2026, 7.2k likes). "The plan is the product" is the repo README's own framing, verbatim: *"The idea: use your most capable model for the part where intelligence compounds — understanding the codebase, judging what's worth doing, writing the spec — and hand execution to cheaper models. The skill never implements anything itself. The plan is the product."* — github.com/shadcn/improve (fetched 2026-07-07).
• Why highest-leverage: it's a complete, installable skill (not a prompting tip) that mechanizes exactly the routing doctrine this user already runs by hand — "Opus 4.8 = orchestrator/reviewer... Sonnet 5 = default executor" — with a shipped execute/review/reconcile loop and worktree isolation matching this machine's own fan-out conventions, plus a working reference implementation of an escalation-and-budget-capped agent handoff (self-contained plans, machine-checkable done-criteria, max-2-rounds revision cap, explicit STOP conditions).
• Exploit: npx skills add shadcn/improve today — genuinely not installed on this machine (checked). Run /improve quick or /improve branch as a pre-review audit feeding into the review-until-clean (L3) loop and /code-review; use /improve execute <plan> as a concrete reference for hardening the Definition-of-Ready gate's escalation/budget fields with an actual working example (max-2-rounds cap, STOP conditions) rather than prose-only guidance; run /improve reconcile as a session-start ritual alongside the L9 skill-miner inverse-audit loop — one audits transcripts for missing skills, the other audits the codebase itself for missing fixes/tests/perf work. Also pairs with Philipp Schmid's npx skills add <repo> --skill <name> cross-vendor installer already flagged in RESEARCH_top_voices_2.md Ledger F — same install mechanism, a second confirmed-real skill to pull in through it.
• Already-banked? RECLAIMED — was wrongly skipped. /improve is confirmed not installed anywhere on this machine; the original sweep's "already-banked" claim was false.

Part B — Retry: the 6 voices that 429'd in volume 2

All six retried via opencli twitter tweets <handle> --limit 30-50 -f yaml (the 429-resistant chronological timeline, per the prior lanes' own finding), with search/thread as a fallback and real spaced retries — not a single-shot re-ask. agent-reach doctor --json confirmed the Twitter/X backend was healthy (OpenCLI, no active rate-limit) before starting.

Erik Schluntz (@ErikSchluntz) — RETRIED, success

• Item: teams of parallel Claude/"Mythos" agents write large programs measurably faster than a single agent. "Teams of Claude Mythos agents can write large programs 3x faster than a single agent" — x.com/ErikSchluntz/status/2064404858946617692 (Jun 9, 2026)
• Why highest-leverage: a direct, internal-Anthropic data point on multi-agent fan-out ROI for large coding tasks — exactly the decomposition/orchestration bet the loop-engineering catalog and subagent-pinning doctrine are already making.
• Exploit: pilot a controlled fan-out benchmark on a real feature build — Opus decomposes into independent subtasks, N parallel Sonnet execute-agents (à la L1 babysit-fleet's worktree-per-unit pattern) vs. one long single-agent build of the same spec, timed both ways. If the ~3x figure replicates on this stack, codify it as a new named loop ("parallel-build") in loop-engineering/LOOPS.md with the decomposition rule as its Definition-of-Ready gate.

ThePrimeagen (@ThePrimeagen) — RETRIED, success

• Item: a cheap self-review technique — make the model explain what it just did in plain language, then critique that explanation for logic flaws — that he says surfaces a bug on almost every change. "'I just got done doing "mansplain what you did" and I want you to review it and tell me what I have missed, what could be a logic flaw.' Even that alone will surface 1 or 2 things I have done wrong almost with every single change I make." — x.com/ThePrimeagen/status/2074137643865018390 (Jul 6, 2026)
• Why highest-leverage: model-agnostic, nearly free, and immediately pluggable into any code-review gate as a pre-check — not an anecdote, a repeatable step.
• Exploit: add a mandatory "mansplain what you did, then find the logic flaw" self-critique pass inside review-until-clean (L3) and the /code-review flow, run on every commit before escalating to codex:rescue/Codex peer review — cheap enough to run always, and catches issues before spending a Codex/Opus review pass on them.

Barry Zhang (@barry_zyj) — RETRIED, genuine null

No in-window item. Full chronological timeline (tweets --limit 30 and --limit 50, both clean, no 429) runs gapless back to 2023 with nothing after a Dec 10, 2025 retweet; most recent original tweet is Oct 16, 2025. search "from:barry_zyj" (with/without a date filter) 429'd twice after a cooldown pause, but since the 429-resistant timeline endpoint returned a complete, unbroken history with nothing in-window, this is confirmed account inactivity, not a rate-limit artifact.

Mahesh Murag (@maheshmurag) — RETRIED, genuine null

No in-window item. Full chronological timeline (tweets --limit 30 and --limit 50, both clean) is gapless back through 2025; most recent activity is an Apr 17, 2026 retweet, most recent original tweet Apr 8, 2026 (a strong Agent Memory design post — "filesystem-pilled, versioned, attributed" — but ~90 days old, outside the ~45-day window). search fallback 429'd twice after cooldown; the clean timeline confirms this is genuine inactivity in-window, not a rate-limit failure.

Nat Friedman (@natfriedman) — RETRIED, success

• Item: replying to a skeptic about the Vesuvius Challenge's full read of a Herculaneum scroll, he clarifies the model-architecture choice that prevents hallucination in the extraction pipeline. "The models that generate these outputs are not LLMs and are not trained on letterforms; there is no risk of the type of mistake that you are worried about" — x.com/natfriedman/status/2071234196412989624 (Jun 28, 2026)
• Why highest-leverage: a live architecture defense from someone running a real, high-stakes extraction pipeline — the reusable pattern is "use narrow, non-LLM models for deterministic structural extraction; reserve general LLMs for interpretation," not scroll trivia.
• Exploit: for the Mission Control transcript-forensics tool, don't route deterministic sub-tasks (parsing tool-call structure, detecting loop-failure signatures, extracting decision points) through an LLM judge by default — build/keep those as narrow classifiers or pattern extractors, and reserve Opus-as-reviewer for genuinely ambiguous semantic calls (was this decision sound, is this deviation acceptable). Extends the existing routing-matrix doctrine from "match model tier to task difficulty" to "match model type to task determinism."
• Retrieved via search "from:natfriedman since:2026-05-24" after the plain tweets timeline surfaced only stale 2025 posts — a real, spaced retry on a different endpoint, not a single-shot re-ask.

Linus Lee (@thesephist) — RETRIED, success

• Item: commenting on a Thrive-portfolio company's OpenAI-built tax-prep agent (7k+ returns processed this season), he endorses a specific closed-loop production design. "I really appreciate the lessons and technical ideas @samaysham & team were able to share about their tax agent system, which learns from production traces to self-improve via detailed tracing tightly integrated into deployment + an autonomous AI engineer." — x.com/thesephist/status/2059746164694557069 (May 27, 2026)
• Why highest-leverage: an investor who sees many production agent systems endorsing "production traces feed self-improvement, with an autonomous AI-engineer role between deployment and iteration" — exactly the unimplemented end of loop-engineering + Mission Control transcript-forensics.
• Exploit: close the loop on the named loops (review-until-clean, wiki-compile, babysit-fleet, heartbeat-orchestrator) — pipe every scheduled run's transcript into Mission Control as a production trace, and give a standing Opus reviewer role a recurring pass to mine those traces for failure patterns and auto-propose prompt/skill edits to the loop definitions, instead of treating each loop's prompt as a fixed artifact only touched by hand.
• Secondary source pulled for corroboration: auto-captions for his Cursor "Compile" talk ("Notational Intelligence," yt-dlp transcript) — theoretically rich but less directly tactical than the X item above, so not used as the primary pick.

Retry yield: 4 of 6 delivered, 2 genuine nulls. Erik Schluntz, ThePrimeagen, Nat Friedman, and Linus Lee all produced real, dated, verbatim-cited in-window items once the cooldown cleared. Barry Zhang and Mahesh Murag remain honest nulls — not because of a rate limit this time, but because their own X timelines are genuinely gapless-empty in the window (confirmed via the 429-resistant tweets endpoint at two limits each, not a single failed call).

Provenance (corrections pass)

Sweep 2026-07-07 evening. Live-system checks via direct grep/find/Read against ~/.claude/CLAUDE.md, ~/.claude/skills/loop-engineering/{SKILL.md,LOOPS.md}, ~/.claude/commands/, ~/.claude/plugins/installed_plugins.json (no research-doc self-citation counted as evidence). shadcn reclaim sourced via opencli twitter tweets shadcn --limit 40 -f yaml, opencli twitter search "from:shadcn improve" -f yaml, and curl -s [r.jina.ai/https://github.com/shadcn/improve](https://r.jina.ai/https://github.com/shadcn/improve`) (full README, fetched live). Six retries run as three parallel Sonnet subagents using opencli twitter tweets <handle> as the primary (429-resistant) endpoint with search/thread fallbacks and real spaced retries across endpoints; agent-reach doctor --json confirmed Twitter backend health before dispatch.