Workflows

70-Hour Run on Max 5x: Delegation Kept the Weekly Meter at 42%

Actual usage logs from one long autonomous run instead of impressions about quota: a single resident agent stayed alive 70h24m on Max 5x, spawned 31 child runs across Claude and Codex, and merged 27 PRs while the weekly meter moved from 2% to 42%. The pattern is that the expensive model holds the goal and state, splits work into chunks, delegates what it can, and waits rather than burning quota — including re-dispatching work to Claude when Codex hit a quota floor.

conclave: Advisor and Executor Roles That Rewrite Their Own Skills

A Claude Code plugin that runs a team of AI advisors and executors with persistent memory, hard role boundaries, and a mandatory session lifecycle. The notable part is the feedback loop: recurring mistakes become durable edits to the agents' own skill files, so the correction survives the session instead of being re-explained.

brain-tree-os: Local-First Project Management System for AI Agents

A local-first project management layer for coding agents built from structured knowledge bases, execution plans, personas, and slash commands. The idea is that project state lives in files the agent reads rather than in a conversation that gets compacted away. Useful if you run long multi-session projects and keep losing context.

Should Coding Agents Have Memory, or Only Verified Lessons?

A discussion of why dumping old transcripts or auto-extracting 'memories' is risky: a lesson can be outdated, wrong, or specific to one situation, and a fresh session will happily apply it anyway. The author's project (Belay) instead promotes only lessons that have been explicitly verified before they carry forward. Worth reading if you are designing your own memory layer.

Legion-Wallpaper: Multi-Agent OS Where No Claim Ships Unverified

An AI image restoration pipeline for Windows, notable less for the restoration than for the multi-agent Claude Code operating system that builds it: no agent's claim ships until an independent verifier tries to falsify it. A worked example of adversarial verification as a build discipline. Includes a metric-plus-vision gate ladder.

reskill: The Publishing Pipeline for a Skill You Just Wrote

Covers the step after authoring a skill: code audit, quality gate, README and SKILL.md generation, publishing to GitHub and SkillHub, and collecting feedback. Turns 'I wrote a skill' into 'other people can install it' without the usual manual packaging. Chinese and English documentation.

know-your-unknowns: Blind-Spot Passes and Pre-Implementation Interviews

A Claude Code plugin built around the things an agent does not know it does not know: blind-spot passes, domain primers, pre-implementation interviews, tweak-likelihood plans, deviation logs, and merge quizzes. The interview step in particular forces unstated requirements out before code gets written. Aimed at reducing confident wrong implementations.

oh-my-teams: PM/PL/Senior/Junior Agent Org Running on Orca

A Claude Code and Codex plugin that models a software org as agents — PM, PL, Senior, Junior, Worker — running on top of Orca. Work flows down the hierarchy and results flow back up, rather than one agent doing everything. Korean-language README.

Agentic Engineering: Let the Agent Write Its Own Project Memory

From NirDiamant: one command has the coding agent read your real code, write its own project memory file, then grade the result. Addresses the cold-start problem where every session begins knowing nothing about your repo. Because the memory is derived from code rather than transcripts, it stays closer to ground truth.

Do You Have Claude Check Git History Before Refactoring?

On mature repos, an odd-looking check in a function is often there because an integration broke without it, and the reason lives in an old commit rather than a comment. The thread argues for making the agent read git history before it proposes deleting anything it finds unnecessary. Practical guardrail for agents working in code they did not write.

DECISIONS.md: Keep Rejected Approaches Alive Through Compaction

Compaction summarizes the state of the code, and a rejected idea leaves no trace in the code, so an hour later the agent confidently re-proposes the caching layer you spent twenty minutes ruling out. The fix is a DECISIONS.md file on disk recording both what was decided and what was rejected and why. Cheap, and it survives every compaction.

business-crew: 18 Persona Agents Running a Shape Up Cycle

A whole startup team for solo developers: 18 agents with real personas, a Shape Up cycle with appetite, hill chart, and circuit breaker, plus art direction judged against an Awwwards rubric. Product-agnostic — SaaS, ecommerce, landing page, or internal tool. Spanish-language README.

speckit-azure-interview: Structured Azure Interview Before the Spec

A Spec Kit extension that runs an adaptive Azure architecture interview before specification, capturing requirements, existing resources, constraints, ownership, networking, security, governance, and open decisions. The output is validated input for spec-driven IaC development. Front-loads the questions that otherwise surface halfway through a Terraform run.

Testing Published Skills on Every PR With 1,300 Eval Tasks

A team publishing ~25 skills describes their quiet failure mode: a skill still lints, still loads, and silently stops doing the thing it was for. Their repo carries ~1,300 eval tasks — each a prompt, a setup, and mostly deterministic checks on what the agent produced — and every PR runs the tasks for its changed skills in CI. Their eval harness is Apache 2.0.

agentic-community-college: Lessons Split Into Test-Defined Chapters

A Claude Code learning framework where a course plugin splits a lesson into chapters defined by tests, then a conductor implements each chapter in a seeded workspace, explains it with an HTML artifact, and closes with an end-to-end test and summary. Bring your own course. The test-as-chapter-boundary idea is transferable beyond teaching.

Changelog Archaeology on Why Everyone Is Burning Limits Faster

A trawl through the last month of changelogs for candidates explaining the sudden limit burn, notably v2.1.232 turning on subagent forking by default (a fork inherits the entire transcript) and backgrounding non-teammate spawns by default, which makes the model spawn them more opportunistically. In long sessions the two compound. Includes mitigation tips.

A Token Discipline That Cut Weekly Burn Without Losing Quality

After exhausting a weekly quota in 24 hours, the author restructured: main agent on Opus understands the problem and gives a visual flow, a Fable agent prepares the detailed spec, and an architect agent critiques the design while a tester agent writes cases against it. Includes screenshots of the resulting usage. Concrete role-per-model assignment rather than general advice.

Moving Project State Out of the Conversation and Onto Disk

The failure mode: after enough iterations the agent redoes finished work, loses track of why one task depended on another, and marks a task complete based on what the conversation said rather than what is in the repo. The fix was making the plan a real Markdown file with tasks as rows, declared dependencies, and a report written next to each task on execution. Validation reads the repo, not the transcript.

claude-code-dev-flow: Ticket-Driven Tests-First Unattended Runs

A workflow for running Claude Code unattended against a local model, organized around tickets with a tests-first discipline. The tests provide the completion signal an unattended run needs, since nobody is watching to judge 'done'. Relevant if you are pushing agent work onto local inference.

Distributed Multi-Agents Across a Fleet of Embedded Devices

A different take on multi-agent work: not subagents inside one session, but agents distributed across embedded devices, with Ansible handling fleet automation, version control, and large-scale deployment of code developed and tested locally on representative hardware. Covers what worked and what did not on a heterogeneous fleet. Useful perspective if your targets are not servers.

ai-101: Knowledge Base From Concepts to Hands-On AI Engineering

A structured knowledge base covering Claude Code, context engineering, local LLMs, and AI agents, moving from concepts through hands-on practice. Traditional Chinese with English sections. Reasonable starting point to hand someone getting into agentic coding.

camus: Independent Maker and Reviewer Agents With Real Verification

A local control plane for AI-made work built on independent maker and reviewer agents, deterministic verification, bounded recovery, and auditable evidence. Bounded recovery matters — it caps how long an agent thrashes on a failing step before escalating. Another entry in the growing verify-before-you-trust category.

Opus Orchestrator With Sonnet Subagents: 9 Hours and Heavy Token Burn

A report from someone running plan.md into a max-effort Opus 5 orchestrator that spawns max-effort Sonnet 5 subagents per phase, with a verification pass retrying up to five times. It works, but one medium-complexity task — a single tab in an Android app — took almost nine hours and blew through usage limits. A useful cost data point on the orchestrator/subagent pattern before you adopt it wholesale.

Engineers Who Write All Their Code With Claude: How Do You Actually Do It?

A FAANG engineer with an AI research background admits they never adapted to agent coding, and asks how people ship agent-written PRs that they understand, that contain only defensible changes, and that survive a real code review. The thread is a useful counterweight to demo-driven enthusiasm: the bar is not 'it works' but 'it would pass at a company with its act together'. Worth reading for the workflow answers rather than the complaint.

operator: Multi-Agent Orchestration for Kanban-Shaped AI Development

An orchestration application that models AI-assisted development as a kanban board, with agents picking up and moving cards through the pipeline. The board is the coordination mechanism, so parallel agent work stays visible and reviewable instead of vanishing into one long transcript. Aimed at teams running several agents at once.

prism: Ambiguous Change Requests Into a Spec-to-Verification Lifecycle

Takes a vague software-change request and drives it through a durable lifecycle: specification, human-approved implementation, then verification. State is persisted in Beads rather than in the conversation, so the work survives context loss and session restarts. The explicit human-approval gate before implementation is the design decision worth noting.

obversa: Durable Agent-Team Workflows With Named Roles and a Human Merge

obversa runs agent teams as durable workflows: each agent holds a named role, reviews can send work back down the chain, and a human sits at the merge point. It layers on the engines you already use, with no server and no database to operate. Useful if you want a software factory or domain-specific harness without standing up infrastructure.

Feeding Brand Context to Claude Code via MCP Before a UI Redesign

An agency walks through connecting brand strategy documents — positioning, personality, tone, typography, color and layout guidance — to Claude Code over MCP before asking it to redesign a site. The claim is that an agent given the brand's intent can justify each UI choice against the experience the business wants, instead of defaulting to generic patterns. Includes their own redesign brief as a worked example.

How to Actually Cut Token Burn: Analyze Transcripts, Then Plan

A practical method for users who exhaust their usage fast: learn the real cost model (output vs input, cached vs uncached, the five-minute cache TTL), then have Opus analyze an expensive session transcript to find where tokens actually went. Ask for a reduction plan, have a resumable advisor subagent critique that plan, and read it yourself before acting. The end product is custom subagent briefs and tooling, not just shorter prompts.

Claude Code Telemetry: Disabling It Also Disables Remote Control

A user locking down a dev machine noticed heavy outbound Datadog traffic and found the documented trade-off: DISABLE_TELEMETRY and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC also kill the feature-flag evaluation Remote Control depends on, while DISABLE_ERROR_REPORTING does not. So error reports can be turned off freely, but usage metrics cost you Remote Control. Relevant to anyone running Claude Code in a restricted or air-gapped environment.

Superpowers_Multi_AI: Prompt Framework Forcing Structured SDLC on Agents

A modular prompt-engineering framework for Cursor, Claude Code, and Copilot that imposes a structured SDLC: linear execution, context isolation between phases, and systematic debugging, driven by a standalone Windows launcher. The pitch is replacing ad-hoc prompting with a repeatable process. Windows-centric, and heavy on structure — try it if loose agent sessions keep drifting.

Claude Code Running Inside Android, Driving Apps via Shizuku — No Root

A full no-root stack: Termux runs Debian, Claude Code runs in Debian, and Shizuku gives it adb-level access back to the host Android. With scrcpy it drives apps on a virtual display in the background while you use the phone normally, and Remote Control lets you talk to the phone from desktop or web. The author's use case was triaging thousands of trip photos into albums; it also builds native apps and widgets on the fly.

bureau: Agentic Engineering System With Isolated Specialists and Cold Review

Novadiem's system for complex software work runs isolated specialist agents, keeps durable run state so work survives interruptions, and adds an independent cold review pass that has not seen the implementation reasoning. The cold review is the distinguishing idea — a reviewer primed by the implementer's rationale tends to agree with it. Aimed at multi-step engineering work rather than one-off tasks.

A Safer Shopify + Claude Code Setup: Read-Only Context and Approval Gates

A Shopify agency's pattern for connecting Claude Code to a live store without letting it operate the store. A versioned Store Brain repository holds brand voice, catalog rules, customer language and safety rules while live data stays in its source systems; read and write tools are separate, with the narrow write tool loaded only after approval. Diagnosis precedes implementation, 'done' requires diff, checks, QA checklist and rollback steps, and publishing to production stays a human action.

Seven Months of Claude Code Logs: Cache-Miss Rate Beats Dollar Totals

A max20x user parsed ~/.claude/projects across 722 sessions and 88 projects, then priced it at API rates — and argues that headline dollar figure is meaningless on a subscription. The number that mattered was a 6% cache-miss rate, which on a subscription translates into lost minutes inside each five-hour window rather than money. Also notes that a 96.9% average cache hit rate hid one project reusing 0% across three sessions.

Indirect prompt-injection study: the harness changed the outcome

One arm of a 356-trial prompt-injection study ran through the Claude Code CLI, with the injected instruction arriving through file and issue tool results rather than the user message. The depth pass tested two concrete outcomes — exfiltrating a planted credential and fetching a cloud instance-metadata endpoint — and Haiku produced real credential exfiltrations in 18 of 30 valid runs while Sonnet recorded none in the tested cells. A concrete reminder that tool output is untrusted input and that model choice materially changes agent safety.

fable-lite: hand the grunt work from Fable down to cheaper models

A plugin that makes the Fable session a pure orchestrator — it understands the request, makes the design calls, writes briefs, and reads every diff before accepting it — while routine work goes to Opus or Sonnet subagents. Each work item is scored 0-2 on five axes (files touched, exemplar availability, and so on) to decide whether it gets delegated. The aim is to stop burning expensive tokens on grepping, mechanical edits, test runs and doc changes whose shape was already decided.

Asking Claude Code to use the product as a buyer found bugs tests missed

After weeks of work on a FastAPI + Next.js project with tests, type checks, lint and build all green, the author asked Claude Code to start from a clean generated project, follow the setup, boot the services and sign in through the real UI. It got stuck on the first login — Clerk redirected to routes that did not exist — and kept surfacing first-run failures no test covered. A cheap end-to-end sanity pass worth running before any release.

A methodology for benchmarking whether agent tools actually save tokens

Memory tools, token savers, skills and plugins all advertise savings, but almost none disclose how they measured, and the author argues most published numbers come from unrealistic scenarios. Having built a memory tool themselves, they walk through the benchmarking approach they used to check their own claims. Worth reading before adopting a tool on the strength of its README.

Token usage is mostly an outer-loop problem, not a model problem

The author's position is that Claude works best inside Claude Code and the inner harness is better left alone than replaced. The real gains live in the outer loop: which CLIs are available, how the codebase is indexed, clearing output, and how you structure rebasing, conflict prevention and mid-turn steering when a problem is spotted early. Their claim is roughly +30% useful work per token despite the recent quota tightening.

Sojourn for iOS: a shipped Swift app from 45 one-shot prompts

A published iOS topical Bible study app, written in Swift with a streaming chat interface, whose author never typed a line of its code. The post is about the process rather than the app — how one-shot prompting evolved over several years into something that reliably produces a shippable result, and what the author now does differently.

core-team: a self-deploying multi-agent framework for Claude Code

A Facilitator plus a development team of subagent roles, with persistent memory and quality gates. The framework bootstraps itself into a project rather than requiring manual wiring. Documentation is in Russian.

covener: spec-driven development for agent teams in regulated domains

Built around governance rather than speed — specs drive the work and decisions are recorded so they can be audited afterwards. Targets regulated domains and large codebases where 'the agent did it' is not an acceptable explanation.

agent-discipline: repo work discipline plugin for coding agents

A methodology prompt section plus artifact scaffolding — AGENTS.md, a feature checklist, verification gates — and a compliance audit that checks the agent actually followed them. Packaged as a DeepSeek Harness bundle; documentation is in Chinese.

ai-engineering-team: cross-platform multi-agent engineering framework

A multi-agent framework designed to run the same engineering roles across Gemini, Claude and Codex instead of binding to one vendor's agent format.

factory: Claude Code builds, Codex reviews, guardrails decide

A small software factory on Herdr that splits roles by tool: Claude Code plans and implements, Codex reviews the result, Beads carries issue memory across sessions, and mechanical guardrails — not a model — make the accept-or-reject call.

harness-workflow: a context-aware project harness for coding agents

A shared workflow and project harness that works across Codex, Claude Code and Cursor, keeping the same context conventions whichever agent you happen to be driving.

bro: declare each agent persona once, sandboxed with only its own keys

Each persona — a 'bro' — is declared once with its prompt, tools, secrets, procedures and the list of other personas it may summon, then comes to life in its own sandbox holding exactly that and nothing more. The pitch is a fix for prompt chaos, wide-open API keys, MCP overload and agents with free rein over your machine. Works on any harness and any model.

my-blog-supporter: a blog-writing workflow that keeps the author in charge

A personal Japanese-language workflow for writing blog posts with Claude Code across four stages — core, dig, assemble, write — with isolated review, concept diagramming, an HTML preview with figures for reading while revising, and a publish gate.

jedi-review: an adversarial review tribunal for Claude Code

Runs parallel attack lenses over a change, tries each finding before a skeptic, re-attacks the fixes, and gates on zero confirmed defects while keeping a defect ledger. A structured take on adversarial self-review.

agent-parley: coordinate Claude Code and Codex across git worktrees

Gives each agent its own worktree while sharing issue ownership, with explicit handoffs so two agents working the same repo do not collide.

threads-newsroom: Five-Agent Editorial Pipeline for a Threads Blog

A five-agent newsroom workflow (Russian-language) for running an expert blog on Threads: one agent plans, others draft, fact-check, and publish only after explicit human approval. It bundles post formats built around real numbers and a 20-rule style guide aimed at keeping the voice human rather than generic.

Deciding When Claude Code Is Actually Done: Stop Conditions

A discussion that frames the mental load of reviewing agent output as verification debt: if 'done' means reading the whole transcript, delegation is just babysitting. The author's loop is one agent implementing and a second scoring the change against explicit checks, with failures cycling back until they pass. The thread collects stop conditions other people use in practice.

tomte: GitHub Actions That Take a Labeled Ticket to a Merged PR

Reusable GitHub Actions workflows that orchestrate coding agents end to end: label a ticket and the pipeline produces a merged pull request with no human in the path. The merge gate lives in CI, so quality control is a test suite rather than a reviewer.

Why Claude Code Burns a 5-Hour Limit in 30 Minutes: the Token Math

Walks through where quota actually goes on a broad prompt like 'fix the bug in the auth flow': glob and grep pull 10-15 files into context, and every subsequent turn re-sends all of it. The argument is that most of the burn is dead weight from unfocused exploration rather than any quota change, along with suggestions for scoping prompts to avoid it.

octopus-factory: Recipe-Driven Autonomous Pipeline With Quota Fallback

A recipe-driven pipeline for Claude Code and Claude Octopus that runs multi-agent build, audit, and release stages autonomously. Includes quota fallback, so a session that hits a limit degrades to another path instead of stopping outright.

solowright: Spec-Driven Development System for a Solo Builder

You write the spec; the system plans, builds on tiered models to control cost, reviews at fixed gates, and reports back in plain language. Built for Claude Code and explicitly scoped to one person working alone rather than a team.

GoHarness: Agent-Assisted Development Cycle as an Installable Plugin

An agent-assisted development cycle for Claude Code, packaged as an installable plugin, shipped alongside a sample app built entirely with it. The example app is the useful part: it shows what the cycle produces rather than just describing it. Spanish-language README.

harness-template: Separate the Implementer From the Verifier

A Claude Code development framework that splits the implementing agent from the verifying one, seals hidden tests behind encryption so they cannot be read and gamed, and keeps regression tests over the anti-cheating mechanism itself. Traditional Chinese README.

AunoForge: AI-assisted open-source maintenance you can verify

A workflow for the unglamorous parts of maintaining an OSS project: triaging issues, reproducing bugs, reviewing PRs, checking for regressions and security problems, and preparing releases. Each step is designed to produce evidence a human can check rather than a verdict to trust.

lock-master: portable file locks so parallel agents stop clobbering

A zero-dependency locking scheme for multi-agent work built on plain LOCK*.txt files. Supports exclusive and team locks, path scopes, expiry, stale-lock cleanup, and cloud-sync-friendly storage, with a cache for a fast overview of who holds what.

baseline-ops: markdown runbooks for agents deploying Go apps on one host

An operations repository containing nothing but markdown: runbooks for deploy, rollback, and restore, pinned version numbers, and the Docker, Caddy, and Compose templates every project copies. Written so an AI agent can follow it directly. Companion to the author's engineering baseline repo.

An enterprise engineer's honest take after maxing weekly limits

A working report from someone using Claude Code heavily on enterprise-level code across several subscriptions, not vibe coding. The main advice: keep a separate project holding reusable best practices split into narrow, path-scoped sections — form validation, API sanitization — rather than one large rules file. Invites others to compare notes.

An AI-run news site published nothing for three days: the editor said no

A build report from someone running a news site where seven agents handle reporting, writing, and editing. The premise was that accurate articles can still mislead, so the editor agent was tuned against framing and sensationalism — and it rejected everything the other agents produced for three days straight. An honest account of a multi-agent quality gate set too strict.

Are coordination packages like orca worth it for multi-account setups?

A practitioner describes their current setup: two or three Claude accounts and a couple of Codex accounts at the CLI, with one Fable instance acting as coordinator and the rest communicating directly or through a shared mailbox using radio-style acknowledgements. They find it fiddly to rebuild each time and ask whether existing coordination packages are worth adopting.

agent-loops: run a task loop across several CLI coding agents with roles

One controller drives a loop over multiple CLI coding agents in a fixed role order, keeping a single persistent session per role so each agent accumulates its own context instead of starting cold every pass.

dev-flow: 46 agent skills and a filesystem contract, idea to production

Coordinates a product build through a .workflow/meta.json contract plus 46 agent skills covering web (Next.js 16) and mobile (Expo/React Native), with an 'eve' agent engine and Linear/scrum integration. Runs on Claude Code, Codex, Copilot, Gemini, and Cursor.

Autonomous agents don't need less control, they need it somewhere else

An argument that Cursor feels controlled because you sit inside the edit loop, but that is the wrong place for an autonomous agent. Instead of supervising every edit: isolate the work, give the run explicit boundaries, make progress observable, and stop at meaningful gates. Control moves from the keystroke to the environment.

Cotal: a proposed open standard for agent coordination

An attempt at a common protocol for agents to coordinate with each other, rather than every orchestrator inventing its own message format.

manga-honyaku: code does the geometry, the agent does the comprehension

A manga translation workflow split along its natural seam: deterministic code handles panel and bubble geometry while an LLM agent handles reading and translating. A clean example of not asking a model to do what a library does better.

agent-leash: LEASH-8, a control model for agents with delegated authority

An eight-domain control model for agents acting on your behalf, with a scorecard, an approval-design checklist, and a plan-versus-authorize pattern separating what the agent decides from what it is allowed to execute. Drawn from a live production agent operation and sanitized. MIT.

fanout: Claude Code orchestrates other coding agents in git worktrees

Lets Claude Code act as lead over the other coding agents you already subscribe to, dispatching them to work in parallel inside isolated git worktrees. Each branch is reviewed and proven before anything merges back. Useful if you pay for several agents and want one of them coordinating the rest.

agentic-dev-toolkit: shared agent instructions and model routing

A portable workstation setup bundling agent instructions, harness adapters and model-routing configuration that works across Claude Code, Codex and OpenCode. The point is to keep one set of conventions rather than re-tuning each harness separately. Handy when you move between machines or agents often.

AISEF: gated pipeline from a requirements file to a working app

A framework that takes a single requirements file and drives it to a finished application through a series of gates, with evidence required at each step. Agents supply the judgment while ordinary code enforces the guarantees, so the process does not rely on the model behaving. Aimed at people who want repeatability rather than one-shot generation.

Re-deriving a minimal agent harness: what does one actually need?

A write-up from someone who spent weeks using Claude Code to build a small agent harness, not as a product but to understand harness architecture. The core argument is to invert the usual drift, letting architecture define sessions instead of sessions quietly defining architecture. Uses DeepSeek Harness as the reference point for what a modern harness requires.

agent-dev-team: Claude Code plugin that staffs work like an eng org

A plugin that assigns work across 21 roles including PM, tech lead, engineers, reviewer, SRE and security, each capped at one of four seniority tiers, with 26 supporting skills. Slash commands cover team, spec, plan, build, review and ship. The stated goal is to stop a single assistant from making decisions above its pay grade.

mARC: subagent relay with a tech lead and pre-merge security gate

Installs an AI engineering team into any repo as a single Claude Code plugin. A tech-lead agent orchestrates specialist subagents for development, SRE, design and security, and a security gate must pass before a merge is allowed. Aimed at teams who want the review step enforced rather than optional.

docket: a decision ledger so agent decisions survive compaction

A ledger for long-running agent work that records decisions as they are made, so they remain in force after the context window is compacted. Addresses the common failure where an agent quietly re-litigates something it settled an hour ago. Small and repo-local.

Mobile Dev on Claude Code: Run Sessions From a Phone via SSH and tmux

A practical guide to continuing Claude Code work from a smartphone by combining SSH, tmux, and multiple machines. Covers keeping sessions alive so a run started at a desktop can be picked up on a phone and handed back. Useful for anyone who wants long agent sessions to survive leaving the desk.

forge-plugin-claude-mp: Route Feature and Bug Work Through PDLC Workflows

A free Claude Code plugin that automates the product development lifecycle by routing incoming feature requests, bug reports, and architecture work into structured workflows. Each request type follows its own path instead of a generic prompt. Aimed at teams that want consistent process without manual triage.

zero-drift: Track Tasks Across Sessions to Keep Agents on the Plan

A tool that keeps AI assistants from drifting during long conversations by tracking outstanding tasks across sessions. State persists past compaction, so the agent can be pointed back at what it was actually asked to do. Targets the common failure where a long session quietly abandons half its plan.

the-agentic-engineer: A Blog and the Agent Pipeline That Ships It

The source behind agentic-engineer.com: both the blog itself and the agent pipeline that writes, lints, and publishes its posts. Valuable less as a product than as a worked, readable example of an end-to-end content pipeline driven by coding agents.

oficina-de-ia: Claude Code AI Office OS Set Up in Seven Questions

A Spanish-language “AI operating system” for Claude Code that learns what you do for a living, connects to your email and apps, and copies the way you do your tasks. It watches for work you repeat and turns it into something that runs on its own. Setup is a seven-question install.

Codifying Agent Behavior: Contracts Instead of Ever-Longer Prompts

An argument that as models get smarter the prompts should shrink while the structure around them grows. The author proposes a set of contracts — state, capabilities, verification, escalation, execution — as a way to make behavior at an agent's boundaries deterministic and easier to reason about. Links to a longer Medium write-up.

295 Claude Code Tools Installed, Six Used: Not a Search Problem

After collecting 295 agents, commands and skills in ~/.claude, the author uses six — and argues better discovery is not the fix. The unused pile splits in two: things installed for a one-off job that will never recur, which is just normal, and things you would genuinely want on the day the need arises but will not remember exist. Only the second pile is a real problem, and lumping them together sends you chasing the wrong fix.

stochastic-consensus: Rank Ideas by How Often Subagents Reinvent Them

Fans out independent subagents in Claude Code, merges everything they produce into one pool, then ranks ideas by how many times they recurred independently. Repeated convergence becomes the signal rather than any single agent's confidence.

Driving Claude From Codex as a Translation Layer: Anyone Doing This?

A developer who plans with Fable, implements with Sonnet or Opus and reviews through Codex finds Claude's replies too verbose and jargon-heavy, and CLAUDE.md rules have not fixed it. Rather than move projects that were designed and scaffolded around Claude's context, they are considering using Codex purely as an interpreter in the middle, and ask whether anyone else runs that setup.

Vertical Slices or Whole-Feature Prompts: How Do You Structure Work Now?

Two years in, the author has rebuilt their workflow three times — from prompting one function at a time and wiring it together by hand, to vertical slices with generated tests, to describing a whole feature and letting Fable 5 build it. That last step works but feels strange, so they ask others who have been at this a while whether they still slice, who writes the evals and tests, and what a 2026 dev cycle looks like.

Nereus: Interview to Spec to TDD Build With Hooks That Actually Block

An opinionated development harness for Claude Code that runs interview, spec, TDD build, parallel review and finish as distinct stages. Its hooks are enforcing rather than advisory — they block when a stage's conditions are not met.

A Context Management Setup for Claude Code Across 10+ Repos

A founding engineer at an early-stage infra company with a microservices layout describes teaching their agent who calls whom across more than ten interdependent repositories. First came a knowledge graph spanning all of them, which helped enormously; the second bottleneck was babysitting the same context into every new session.

Dynamic Workflows Are Still Unmatched and Under-Discussed

The author argues Claude Code's dynamic workflows remain the standout feature no other harness, Codex included, has matched: you can orchestrate with Fable 5.1 while using non-Anthropic models as executors through their own CLIs. They stress this is not the same thing as subagents.

Delivery Discipline Layer: Make the Agent Prove It's Done

A behavior layer aimed at turning “the agent says it's done” into “the agent proves it's done”: a pre-implementation gate, one backbone plus two collaboration forms, evidence-based review, and acceptance in the real environment.

blackice: Adversarial Reviewer Panel With a Ruin-Class Circuit Breaker

A human-in-the-loop code review panel that runs a bounded loop of reviewer agents whose job is to break your change. A ruin-class circuit breaker halts the loop when a finding is severe enough to warrant stopping.

openshard: Route, Gate, and Verify Work Across AI Coding Agents

An orchestration layer that routes tasks across models, gates risky actions behind approval, verifies results, and keeps a durable execution record. The framing is receipts — every agent action leaves an auditable trail. Relevant if you run unattended agents and need to answer what actually happened afterwards.

StarFix: Playbook for One AI Captain Directing a Terminal Agent Fleet

A playbook plus scripts for running one long-lived coordinating agent that directs a fleet of terminal AI workers, covering protocols, monitoring, task dispatch, context handoff, and trajectory compilation. It also ships a benchmark for the coordinating agent itself. Documentation is primarily Chinese; the multi-agent handoff patterns are the draw.

watching-claude: External Supervisor That Auto-Resumes and Verifies Runs

An external supervisor process for Claude Code that automatically continues stalled runs and uses DeepSeek to review the output, so a long task can finish unattended. The pairing of one model doing the work and another checking it is the notable design choice. Documentation is in Chinese.

Lessons From 3 Months of Claude Coding an MMO Around the Clock

A developer ran Claude Code continuously for three months to build a browser-based horror MMO, reaching 1800+ versions. The workflow that held it together: one new version file per cycle, a written request log so feature asks are never lost, dedicated polishing cycles between content sessions, and a second agent auditing the coding agent's output.

project-engineering-os: Bootstrap Repos With Governance and Spec-Driven Dev

An MIT-licensed CLI (npm: create-project-engineering-os) that scaffolds a new repository with governance rules, spec-driven development structure, an agent harness and technical-debt controls already in place.

GARAGISTE: A Six-Agent Dev Team in One Folder of Config Files

An autonomous development team expressed entirely as configuration: six agents that plan, build, verify, review and ship, with no runtime to install. Works in both Claude Code and opencode.

ksforge: Turn User Stories Into Resumable Claude Code Workflows

Converts user stories into controlled, resumable Claude Code workflows, so a long feature can be paused and picked back up without losing the thread of what was agreed.

orchestrator: Run Multiple Coding Sessions and Manage Their PRs

Orchestrates several coding sessions at once and handles the PR side — AI-assisted review handling included — while keeping approval decisions with you rather than the agents.

Beads: A Private Work Graph for ~100 Parallel Claude Sessions

A developer running four tmux sessions of 20-30 Claude Code chats across 30+ Go services describes the three things that actually broke: what is blocked on what, which session did what and why, and what the team knows. The answer was a private work graph sitting between GitHub and the agents.

50 Releases of a Multiplayer Tank Shooter Built With Claude Code

Two months and 50 releases into a vibe-coded multiplayer tank shooter with an active player Discord, the author shares what changed the agent loop — chiefly deploying a small read-only MCP server on the AWS production game server so the agent can observe live state while debugging.

oh-my-sdd: Automating Spec-Driven Development

Automates and simplifies a spec-driven development loop, reducing the ceremony of keeping specs, implementation and verification aligned when an agent writes the code.

sprint-harness: A Diamond-Graph Harness for Multi-Agent Fan-Out

A sprint harness built on a diamond-graph shape — fan out to parallel agents, then converge — for building features with multiple agents instead of one long serial session.

SFLO: A Gated Pipeline Protocol for Building Software With Agents

Simon Factory Lights Out defines a gated pipeline protocol for agent-built software — each stage must pass its gate before the next begins, aiming at unattended runs that still stop when something is wrong.

ai-legacy-migration-framework-kit: Legacy Migration Gates for Agents

A Claude Code and Codex plugin that chains legacy-system analysis, spec approval, implementation and verification into one gated workflow. Each phase only hands off once its spec is approved. Aimed at teams modernizing old codebases with an agent instead of ad-hoc prompting.

claude-code-blueprint: Reusable Agent, Skill, Hook and Rule Scaffolding

A starting blueprint for assembling Claude Code workflows out of agents, skills, hooks and rules, aimed at making behavior consistent and safer across different projects. Good if you keep rebuilding the same setup per repo.

remote-collab-agents: Coordinate Claude Code Across Macs and Linux Boxes

Lets Claude Code agents on different machines work together: remote command execution, file sync, and a trust model for multi-agent workflows that span hosts. For people whose build machine and laptop are not the same box.

agent-compose: Compose Agent Personas, Skills and Tools Into Files

Picks a role, a personality blend, the skills that role can see and the tools it gets, then writes the whole thing out as plain files your harness already understands. Configuration as composition rather than copy-paste.

sdlc: One Story per Session, Nine Gates, Enforced by Hooks

A story-driven delivery loop for Claude Code where each session handles exactly one story and must pass nine gates enforced by hooks. Tests are frozen before implementation starts and the agent writing the code cannot edit them — closing the most common way agents fake a green suite.

omelette-fleet: Gemini, Grok and Codex as Read-Only Reviewers

Brings Gemini, Grok and Codex into Claude Code as read-only research and review units, running on subscriptions you already pay for rather than API billing. Second opinions without giving another model write access to your repo.

dew_flow_conventions: One Copy of Agent Rules Across Five Repos

Keeps a single canonical set of cross-repository rules for AI-agent sessions, mounted into each repo as a git submodule with CI checks that the pinned revision has not drifted. A concrete answer to CLAUDE.md files diverging across a fleet of repos.

superpowers-gstack: Using Superpowers and GStack Together

A workflow manual, routing plugin and CLAUDE.md generator for running the Superpowers and GStack frameworks side by side, each in the phase it handles best. Useful if you already use one and keep bouncing off the other.

watchbill: Parallel Subagents in Worktrees, Coordinated by a Mailbox

Runs parallel Claude subagents in separate git worktrees, coordinated through a file-based mailbox carrying live status, corrections, claims and merge evidence. A supervising agent runs the deck and merges only what the evidence supports.

fagan: Frontier Models Plan and Review, Local Models Implement

An MCP-native autonomous SDLC pipeline that spends expensive frontier-model tokens on planning and review while local models do the bulk of the implementation. The pitch is real engineering discipline — plan, implement, review — on a $20/month budget.

compaction-handoff: Carry a Session Across Auto-Compaction

A Claude Code plugin that writes a verified handoff document just before auto-compaction hits and pastes the continuation prompt back afterwards, so the thread of a long session survives the summarization step.

Giving Claude Code a Voice With a Local TTS Script

A writeup on having Claude speak a short plain-English summary after each meaningful task, piped through a local text-to-speech script. The author's argument is that it cuts the cognitive load of reading terminal output when supervising several parallel agents.

Markdown Is All You Need: Flat-File Agent Memory That Beat a Runtime

A write-up of the markdown memory system the author's agent has run on for seven months: long-term facts live in structured markdown files, with a small MEMORY.md index telling the agent what exists and where to look, keeping always-loaded context small. Tested head to head against a 382-dependency memory runtime on a superseded-fact question, the folder returned the current decision with its source while the runtime returned the stale one. The argument is that the editing rules matter more than the storage engine.

Archflow: 17-Agent Claude Code Plugin That Keeps the Plan in Your Repo

A Claude Code plugin distilled from a year of running one workflow across 20 apps. It uses 17 specialist agents and stores the roadmap and backlog as files in the repo rather than in a chat you lose, reading existing code to write the plan itself. It parks and asks when uncertain instead of guessing. Free and open source, installed via `claude plugin marketplace add AZidan/archflow`.

android-without-kvm: Run and screenshot Android apps in Claude Code containers

A repo and workflow that gets Android 14/15 emulation running inside Claude Code's cloud container despite the missing KVM support, so the agent can build, launch and screenshot your app itself. Also wires up an automatic APK build on every push. Cuts the manual back-and-forth of testing mobile changes by hand.

pact: Spec-driven methodology for Claude Code — spec, plan, build, ship

A terminal-based, agent-controlled software engineering methodology that walks Claude Code through spec, plan, build and ship as distinct phases. Aimed at keeping an agent on rails for larger features rather than letting it improvise from a one-line prompt. One of many spec-driven kits, but a lightweight one.

A Fable 5.1 delegation setup that cut usage versus Fable 5 plus Opus 5

A write-up of one user's multi-model CLAUDE.md setup after switching to Fable 5.1: the chat agent now writes code itself on medium effort rather than delegating to Opus 5, with Sonnet 5 kept for cheap reads and a separate Fable subagent doing an independent review before each PR. Reports lower usage and faster output than the previous delegate-everything arrangement. Anecdotal, but a concrete configuration to compare against.

novahiz: Skill catalog, prompt classifier and a pre-edit enforcement gate

A deterministic layer that sits over AI coding harnesses: it catalogs available skills, classifies the incoming prompt to pick the right one, and blocks edits at a gate until the required checks pass. The point is to make skill selection and guardrails repeatable instead of leaving them to the model's judgment each run.

castra: Execution Posture Harness That Takes Claude Code One Step Further

A harness that wraps Claude Code with an explicit execution posture, aimed at the gap where a coding agent stops just short of finishing the job. It formalizes that final step rather than leaving it to the model's judgment.

groundwork (skrinak): Repo Scaffold With a Taxonomy Guard Green on Commit Zero

A repository scaffold for software built with coding agents, organizing everything into six buckets with a usage README in every directory. A taxonomy guard enforces the structure from the very first commit, so the layout does not erode as agents add files.

Every Connected MCP Server Costs Tokens on Every Turn, Used or Not

A reminder that MCP tool schemas load into context on each turn whether or not the model calls them, so eight connected servers quietly tax every request. The suggested fix is moving rarely-used integrations (the author's example is email) off MCP and onto a CLI the agent invokes through Bash, so nothing occupies context until it is actually needed.

agentic-brownfield-coding: Claude Code Scaffolding for Complex Legacy Projects

Scaffolding and a first-steps process for pointing Claude Code at large existing codebases rather than greenfield ones. Focused on the onboarding problem where an agent has to build enough context before any change is safe.

A Solo Developer's Full Coding-Agent Stack, Repo Layout, and Workflows

A worked account of one developer's standardized agent workflow after several projects: pen.dev for UI/UX design, GitHub Issues and Projects for requirements, Zed with Vim mode, Ghostty, and agent multiplexers (Runner and Orca) for running several sessions. Written as an invitation to compare notes rather than a prescription.

myflow-controller: Takes the Word "Done" Away From the Model

A Claude Code skill paired with a stdlib-only Python controller that decides completion externally: a test gate, scope measured by diff delta, tracked review findings, budgets, and observability. The model no longer gets to declare the task finished on its own say-so.

18 Hidden Token Drains in Agent Sessions, With Fixes for Each

Notes from logging raw API payloads through a local proxy across hundreds of Claude Code, Codex, and Cursor sessions, identifying 18 specific ways context quietly bloats during long refactors. Example: a full pytest or jest run dumping 400 lines of passing dots injects thousands of tokens that then ride along in every subsequent turn — pipe with --quiet or filter to failures only.

The Transcript Should Not Be the Agent's Memory

Argues that conversation history and memory are two different things: long sessions accumulate context, get expensive to reread, and degrade as execution environments, while a fresh process throws away continuity entirely. The brnrd approach separates them — a new process wakes into a compact orientation layer holding task and run state, the repo contract, and the resident's working memory and plan.

A Summer of Claude Code on Garmin Watch Faces: What Worked and What Broke

A hands-on report from shipping Garmin watch faces with Claude Code on a hand-written engine: three old faces ported to current watches in ten days, new faces from concept to store in two to seven days. Covers the per-phase skills used, the guard rails that proved necessary because agents optimized things they could not see, and the rules that emerged from the failures.

Putting Claude Code's Changes Through a Supervised Release Pipeline

An account of building ListMyCar — VIN decoding, listing flow, photo enhancement, pricing suggestions, marketplace exports — where the demo took a weekend but reliability took much longer. Every change, whether from Claude Code, their agent, or a human, goes through identical checks, independent review, and staging, with humans approving anything public, expensive, or destructive.

storytime: Persona-Driven Continuity for Claude Code Collaboration

A continuity system built around personas for working with Claude Code over long stretches, keeping a consistent collaborator identity across the harness rather than restarting cold each session.

research-council: Research a Hard Problem Before Anyone Writes Code

A Claude Code plugin that runs a research phase against a frozen goal statement, so the target cannot drift while investigation is underway. Output is evidence-backed claims written in plain English rather than a code sketch. Meant for problems where the wrong architecture is expensive to discover later.

Getting Out of the Loop: 8 Months of Solo-Building with AI

A long-form writeup of what changed over eight months of building software solo with AI agents, focused on getting the human out of the per-step review loop. Reads as accumulated practice rather than a tool announcement. Worth skimming if you are still hand-approving every diff.

Forcing Claude Code to Externalize Its Decisions Through a Fake Tool Call

An experiment using a proxy to inject a fake tool that Claude Code and Codex must call to state a decision, then comparing what each said it would do against what it actually did. The author is clear these are not real reasoning traces. Code is in the agents-workbook repo, and the technique is easy to reuse for your own audits.

review-ledger: A Ledger-Backed Author/Reviewer Loop Between Claude and Codex

A Claude Code plugin that runs review as a bounded protocol: findings get ids, replies are mandatory, the thread resumes in place, and there is a hard cap on rounds. Codex plays reviewer against Claude's authored changes. The round cap and mandatory replies are what stop these loops from drifting forever.

claude-web-studio: Tiered Agents and a Testing Framework for Web Work

A web development setup for Claude Code combining tiered agents, pipeline skills, hooks, a dated stack reference and — unusually — a framework for testing the agents themselves. The dated stack reference addresses agents recommending outdated library versions. The agent testing piece is rare enough to be worth a look.

token-barrage: Delegate Bulk Reads to a Cheap Local Worker Model

Routes large file reads and repetitive code work to an inexpensive worker model with no SaaS layer or API key involved. Ships an independent benchmark of the widely cited 90% savings figure and reports what it actually found. French-language documentation, beta status.

cactus-fleet-doctrine: The Governance Text Behind a Four-Mac Agent Fleet

Publishes the operating doctrine of a one-person, four-machine agent fleet: the protocol and the mesh, base, manager and delegate contracts, written out as text rather than code. Reads as an organizational design document for agents. Useful if you are scaling past a single session and want prior art.

buildersbook: An Open Curriculum for Orchestrating AI Coding Agents

A structured curriculum for engineers shipping production software by directing coding agents rather than typing every line. Open and community-oriented. More coherent than the usual awesome-list, since it is sequenced as a learning path.

agent-workflow: Local-First Agent Pipeline Runner With HITL Gates

An agent harness for designing pipelines, executing tasks through a runner, and watching human-in-the-loop gates and artifacts on a local-first dashboard. Everything stays on your machine rather than in a hosted control plane. Useful if you want visibility into multi-step agent runs without shipping state to a service.

buildd: Task Coordination Where Agents Claim Work and Open PRs

A task coordination layer for fleets of AI coding agents: you create or schedule tasks, and agents claim them, cut a branch, write the code, and open a PR. Adds missions, roles, and shared memory on top, and is MCP-native so agents connect directly. Aimed at running several coding agents against one backlog without manual dispatch.

quorum: Multi-Model Agents for Claude Code via Generated CLI Adapters

Lets Claude Code delegate to other vendors' coding CLIs through field-tested adapters, and includes a probe-driven generator that builds and verifies new adapters for whatever providers you already have installed. The generator is the interesting part — it discovers a CLI's interface rather than requiring a hand-written integration.

bigin-skills: Spec-Driven Workflow With an Independent Verifier

A Claude Code plugin for spec-driven development: tasks flow through a defined workflow, an independent verifier agent checks the result, and mechanical gates enforce the process instead of relying on the model to comply. Also distills knowledge about pinned library versions so the agent codes against what you actually depend on. A serious take on keeping agent output honest.

Ticketing Workflow Agents to Cheaper Models to Stay Under the Fable Limit

Argues the Fable weekly cap is rarely the bottleneck if you stop letting models improvise one-off workflows. The author has Fable write a specific ticket per agent — task, size, verification rules — and lets a cheaper model do the actual code writing, since most tokens go to writing code rather than architecture. Includes the rule set they hand the orchestrator.

gmc: Parallel Git Worktrees for Parallel AI Agents

CLI that spins up git worktrees so several coding agents can work on the same repo at once without stepping on each other. Also generates commit messages from the resulting diffs. Aimed at anyone running more than one Claude Code session against a single project.

Using claude -p for Bulk Data Processing Instead of the API

Report from classifying 100K+ call transcripts by routing the work through a Claude Max subscription with claude -p rather than paying API rates. Covers the two real caveats: throttling once you push large volumes, and the risk Anthropic changes or removes this path. Includes a linked writeup with the harness details.

coordinator-claude: A PM-Led Operating System for Claude Code

Opinionated end-to-end process for running engineering work through Claude Code from a product-management angle: planning, ticket enrichment, delegated execution, staged review, an explicit ship decision, and durable handoffs between sessions. For teams that want the agent inside a defined process rather than freelancing.

Eval Harness Comparing Fable 5.1 and Astra 6 on a Real Gradle Issue

A Gradle engineer built a harness to test whether a skill or codebase change actually helps a coding agent, then ran it on a real gradle/gradle issue. Both models fixed the bug, but Claude Code read Dokka's source to find the root cause first and shipped a regression test the other skipped. Full diffs, cost and token counts are published.

gsdf: Faster GSD Workflow With One Planner Per Phase and Inline Iterate

Drop-in replacement flow for existing get-shit-done and gsd-core projects that keeps the quality gates but cuts the ceremony: one planner per phase, one executor per plan, and an inline iterate mode where you review the result and reply 'approved'. Aimed at people who found GSD correct but slow.

claude-codex-bridge: Claude Code Workers in Worktrees With Codex as Reviewer

Local orchestration setup that assigns structured work to Claude Code workers in separate git worktrees, then has OpenAI Codex act as the owner reviewing the result before it lands. A concrete take on cross-model review without a hosted service.

project-seed-kit: Reusable Docs Structure and Methodology for New Projects

A prepackaged documentation skeleton and set of conventions to seed new repos with, so agents find a familiar layout instead of you re-deciding structure each time. Useful as a starting point for teams standardizing how CLAUDE.md and design docs are organized.

A Prompt to Find the Files Quietly Eating Your Context Budget

Diagnostic prompt for sessions that feel slower or burn tokens faster than they used to: have Claude find the largest files by size and lines, compute how much of them is prose or comments via a scratch script rather than reading them, dispatch Haiku subagents to check separation of concerns on the worst offender, then scan git logs for accumulating test scripts or memory files.

Playwright's New CLI Cuts Token Use for Claude Code Browser Testing

After finding screenshots cost roughly 7k tokens each while testing a Chrome extension through the Claude-in-Chrome skill, the author switched to Playwright's recently released CLI, which Claude Code drives directly. Testing no longer requires the agent to browse and screenshot its way through the UI.

Make Claude Code's Bash Tool Behave Like Linux on macOS

Fix for the constant friction of Claude assuming GNU tools and bash globbing while actually running zsh with BSD utilities on a Mac. Aligns the session environment with Linux behavior without modifying macOS itself, cutting the self-correction loops that waste tokens and time.

vteam-harness: A Virtual PM/BA/SA/DEV/QA Team With Gates That Can Go Red

One command puts a five-role virtual team to work on your repo, with machine-checkable gates that genuinely fail rather than rubber-stamping. Evidence persists past the session so you can audit what each role did. Works with Claude Code, Cursor, Windsurf, Codex and Copilot.

Making Claude Code and ChatGPT Argue About Your App's UI

A developer ran ChatGPT headless from inside Claude Code, gave both models MCP access to Mobbin, and had them debate what was wrong with their mobile app's design. Two hours later the app had cleaner navigation, tighter copy and a better-placed paywall. Expensive in tokens but a concrete cross-model review pattern.

A Model-Per-Role Split for Running Subagents Without Burning Your Quota

One user's working setup: Fable acts purely as orchestrator (plans, writes specs, spawns agents, integrates results), Haiku scouts for files and symbols and reports locations instead of dumping files, and Sonnet reads docs and source. Keeping the expensive model off grunt work is what keeps usage sane. Practical counterpoint to the common complaint about subagent cost.

Claude Code Prompt-Cache Bugs Confirmed in the Changelog

A rundown of prompt-caching bugs Anthropic has since fixed, citing specific releases: context added after tool results being re-sent uncached every turn, changing effort mid-session invalidating the cache, and agent teammates re-sending tool and skill definitions. Explains why orchestrator-heavy workflows saw extreme usage. Worth reading if your token consumption spiked recently.

ledger: An Engineering Ledger Where Every Agent Claim Can Be Checked

Records claims made about an agent-authored codebase as ledger entries, each one verifiable rather than taken on trust. Targets the failure mode where an agent says a thing is done and nothing in the repo proves it. Gives reviewers a checkable trail instead of prose summaries.

postbag: Two Agent Sessions Exchanging Letters Through Native Doors

Lets any two Claude Code or Codex sessions pass messages to each other under a human-set budget, using native mechanisms with no daemon, polling or hooks. Stdlib Python only. A notably simple answer to inter-session communication compared to full orchestration frameworks.

agent-standards: One Checkout Drops a Shared AI Setup Into Any Project

A single git checkout installs a common agent configuration — skills, subagents, MCP servers and OpenSpec scaffolding — across Claude Code, Kilo, OpenCode, Codex and Copilot. Keeps a team's conventions consistent without hand-copying config into every repo. Tool-agnostic by design.

fast-deployment-execution: A Deployment Skill With One Release Owner

A deployment workflow for Codex and Claude Code built on four constraints: a single release owner, a fixed artifact, bounded execution, and verification of what actually landed. Prevents the common failure where an agent deploys something subtly different from what was tested. Applies to any stack.

Can You Stop CLAUDE.md From Loading Into a Custom Subagent?

A developer building a text-evaluator subagent wants it to judge text with nothing but a rubric in context, but only Explore and Plan skip the CLAUDE.md hierarchy and there is no frontmatter field to opt out. Thousands of tokens of coding conventions leak into every evaluation and could skew scoring. A real limitation worth knowing before you build judge-style subagents.

dual-audit: Bounded Multi-Round Review Between Claude and Codex

Runs a review across two different models where round one is genuinely independent, so neither model anchors on the other's conclusions. Failures stay loud and cannot quietly become an approval in a later round. Directly targets the rubber-stamping problem in agent code review.

agent-harness-workshop: Audit Your Agent Harness With Real Session Evidence

A hands-on workshop that walks through auditing an AI coding agent's harness using actual session transcripts: group the failures, analyze them, implement a fix, document it, then validate. Teaches a repeatable method rather than handing over a config. Good material for a team session.

aifactory: A Ticket Goes In, Agents Build It in an Isolated Proxmox VM

A self-hosted software factory where agents plan and implement inside a dedicated Proxmox VM, code-defined gates run automatically, and humans only review at the end. The VM isolation means a runaway agent cannot touch anything outside its sandbox. One of the more complete takes on unattended agent delivery.

geekstack-flow: Wiki Memory, Task Lifecycle and Risk-Tiered Governance

A structured workflow spanning planning, coding, review, testing and shipping, built on an LLM wiki memory, an explicit task lifecycle, and governance rules that scale with risk. Ships a local cockpit that runs Claude Code, Codex or Copilot agents. More opinionated than most workflow packs.

roster: An Agent-Run Organisation Where Each Staff Member Is a Repo

Every staff member is an AI whose brain is a GitHub repository containing a charter, a memory, and a scheduled session that does a day's work unattended and hands off to the next. Uses GitHub itself as the coordination substrate rather than a bespoke orchestrator. An unusually complete take on persistent, scheduled agent teams.

agents: Multi-Agent Harness With Token Shunting Guard and 16 Domain Skills

A multi-agent orchestration harness bundled with 16 domain-driven skills for Next.js, NestJS, and design systems. Its notable piece is a deterministic token shunting guard that controls how context is routed between agents instead of leaving it to the model. Worth a look if you are building a stack-specific agent fleet.

AI_GAME_QA_TestCase: Deterministic Game QA Test Case Pipeline

A game QA pipeline (tc-team) that auto-generates test cases following the ISTQB test process. Its design choice is that deterministic code, not the model, owns the structure, quality gates, and coverage ledger, with the LLM handling only generation. A reasonable pattern to borrow for any agent workflow where you need auditable coverage. Documentation is in Korean.

busybees: A software factory of Claude Code sessions driven by GitHub issues

Turns a GitHub repo into an autonomous development pipeline: issues and labels dispatch Claude Code sessions, which do the work and open pull requests. Labels act as the control plane, so you queue work the same way you already triage a backlog. Worth a look if you want agent orchestration that lives entirely inside GitHub rather than a bespoke runner.

dev-env: Spec and standards for a local-first code-quality workflow

Documentation-only repo defining a local-first code-quality and Claude Code workflow system — the specification, standards, and reference material rather than the tooling itself. Describes how quality gates and agent workflows should fit together on a developer machine. Useful as a written baseline if you are formalizing your own agent conventions.

microservice.md: A living one-page memory file for every microservice

An architect coming from Cursor used Claude Code to build microservice.md, a convention where each service carries a MICROSERVICE.md describing its purpose, owner, APIs, events, dependencies, data, SLOs, patterns, and security. The file lives beside the code and evolves with it, giving any AI coding tool precise service context. Doubles as material for architecture reviews and documentation.

fapony: Multi-agent dev loop orchestrator — one agent writes and commits, anothe

Multi-agent dev loop orchestrator — one agent writes and commits, another reviews the diff, a fix round runs only if review fails. Vendor-neutral (Claude Code, OpenCode, Codex, anything on stdin), ...

agent-plugins: Claude Code plugins: language-agnostic TDD pipeline and Zig 0.15.

Claude Code plugins: language-agnostic TDD pipeline and Zig 0.15.x corrective context

forge-of-thought: Forge of Thought — an AI cognitive extension for Claude Code t

Forge of Thought — an AI cognitive extension for Claude Code that tempers a raw idea into a precise, self-contained assignment: a versioned document chain (brief → intent → assignment), two isolate...

sabx: A fast, scriptable CLI for SABnzbd - built for AI coding agents like Claud

A fast, scriptable CLI for SABnzbd - built for AI coding agents like Claude Code, Cursor, and Codex. Control downloads, manage queues, and automate workflows from your terminal.

jvsl.monorepo.agents.template: Reference Monorepo with an RFC to Gherkin to Code Pipeline

A worked example of a monorepo already wired for agent pairing: it ships pairing modes, project rules, and a pipeline that moves work from RFC through Gherkin scenarios into code. It builds on a companion code-server dev-container template. Useful mainly as something to read before designing your own agent scaffolding.

Models-Cowork: Task Assignment and Proof-Checked Handoffs Across Five Agent Tools

A coordination layer for running several AI coding models on the same codebase, handling task assignment, conflict prevention when two agents touch the same files, and handoffs that must carry proof of completion. It spans five different agent tools. Worth reading if you have hit merge conflicts between parallel agents.

idea-research: Adversarial Research Agents That Stress-Test a Startup Idea

Runs two research agents against the same startup idea — one trying to kill it, one trying to find the wedge — and reports whether it is worth building. Output is plain English and the market framing is India-first, making it a concrete example of adversarial multi-agent evaluation.

metodoloji: BMAD Methodology Plugin with Mechanical Gates and 123 Skills

Implements the BMAD methodology as a plugin for OpenHands and Claude Code, enforcing a record chain (E to IR to SP to S to QR to PR) through mechanical gates rather than prose instructions. Bundles 123 skills covering the steps, for teams that want an agent workflow with auditable stage transitions.

Prompt-Cache Regression in Claude Code 2.1.252 and What the Fix Changed

A community analysis of GitHub issue #91707, which measured prompt-cache misses jumping from 7.2% in Claude Code 2.1.224 to 29.2% in 2.1.252 across ~5,300 turn boundaries. The poster estimates the recent fixes cut unnecessary input usage substantially in long, tool-heavy agentic sessions. Useful if you pinned an older CLI version and are wondering why your 5-hour limit drained fast.

Scripted Automated Compaction Inside Driver Skills

A write-up of an end-to-end development workflow built from 'driver skills' that dispatch to subagents to take a plan or issue from refinement through execution, review, and pull request. The key change is that context is no longer compacted between steps such as execution and review, which the author found made agents notably more coherent — at the cost of higher token use.

focus.md: A Single File That Survives Compaction Anxiety

A plain convention rather than a skill: at the start of a session the model writes all tasks and important decisions into focus.md, so nothing is silently lost when context compacts. Setup is one line — add 'read focus.md' to your CLAUDE.md or AGENTS.md. Small, tested over several months by the author.

GeeLo: Hands-Off Google Earth Engine Development Loop for AI Agents

A workflow where the agent writes a Google Earth Engine script, runs it against a real server from your machine, reads the feedback, and fixes itself before delivering anything. Works with Claude Code, Codex, Cursor, and Gemini CLI. Removes the manual copy-run-report loop that normally makes GEE scripting painful to automate.

AI-DEV-OS: Reusable Framework for Context, Rules and Agent Workflows

A Vietnamese-language scaffolding kit that organizes context, rules, workflows, documentation, skills, and templates into one reusable structure for working with AI coding agents. Drop it into a project instead of reinventing the same directory conventions each time.

wienerdog: Memory, Habits and a Daily Routine for Your Agent, From Files

Gives an AI persistent memory, habits, and a daily routine using nothing but files — no database, no service. One-line setup for Claude Code and Codex CLI.

great_cto: Claude Code as a 70-Agent Pipeline With Cross-Model Gates

Runs Claude Code as a pipeline of 70 specialist agents where an independent model verifies each stage before the next one builds on it. Spending caps refuse rather than warn, and three decisions stay with you: what gets built, how, and whether it ships.

Guildwork: Governance Kit for Running Parallel AI Coding Agents

Contracts, forms, shared vocabulary, and tool specifications for coordinating multiple coding agents at once — with the incidents that motivated each rule documented alongside it. The incident log is what makes it more useful than a generic conventions doc.

overseer-kit: Portable Handover, Roadmap and Freeze-Review Kit

A governance kit you inject into any repository with `ok init`, providing handover documents, a roadmap structure, and a freeze review step before shipping. Portable across projects rather than tied to one stack.

badi: Workflow CLI With 30 Agents, 84 Commands and 62 Skill Categories

A workflow management CLI for Claude Code, Cursor, and Gemini CLI, shipping 30 agents including a virtual engineering team, 84 commands, and 62 skill categories. Broad rather than focused; useful if you want a large prebuilt surface to trim down.

ai-stp: Build, Verify, Store and Install Complete AI Harness Setups

A CLI whose primary consumer is your agent rather than you: it builds, verifies, stores, selects, and installs whole harness configurations, so a setup can be reproduced on a new machine or project as a unit.

vibe-coding-prompt-template: PRD, Tech Design and MVP Templates

Templates and a workflow for generating product requirement documents, technical designs, and MVP scopes with LLMs inside AI-native IDEs. Useful as a starting structure if your planning prompts are ad hoc.

PXOS: Framework-Agnostic Operational Layer Against Agent Amnesia

PXOS positions itself as an operating layer for AI-assisted product and software engineering, focused on keeping agents from losing context between sessions and from burning tokens re-reading the same ground. It is framework-agnostic rather than Claude-Code-specific. The repo description is high-level, so expect to dig into the source to judge how much of the structure is actually enforced.

supergraph: Enforced Planning, TDD and Review for Coding Agents

An engineering workflow system that makes planning, test-driven development, verification and review mandatory steps rather than suggestions, backed by graph analysis of the codebase. Aimed at stopping agents from jumping straight to code.

Anthropic's commerce-agents Repo and the Missing Payment Layer

A walkthrough of Anthropic's commerce-agents repo, which ships a Claude Code plugin that scaffolds shopping and merchant agents against your own backend. The author's point is that the flow stops at checkout: an agent that actually pays needs a narrowly scoped payment tool with its own card, allowed-merchant list and spend limits rather than access to a human's main method. Includes a pitch for the author's own gating tool.

maintainer-agent: Unattended Repo Maintainer That Acts Only on Proof

An agent that maintains a single repository without supervision: it reviews, files issues, prunes and merges. Its distinguishing rule is that it only acts when it has proof that a guard actually bites, which is a much stricter bar than the usual 'agent thinks tests passed'. Worth reading for the guard-evidence pattern even if you do not run it.

Jira Ticket to Reviewed Playwright PR, Gated by Deterministic CI

An end-to-end test framework where a Jira ticket becomes a Playwright pull request authored by AI agents, mirrored into a test case management system and gated by deterministic CI checks. Built on the saucedemo demo site so it doubles as a reusable template. Shows a concrete division of labour between agents that write and CI that decides.

Cutting Multi-Agent Costs: Haiku Orchestration and a Python State Machine

After finding spec-driven development with multi-agent Claude Code burned more budget on reviewing and re-verifying specs than on writing features, the author inverted the setup: Haiku for orchestration, git work and first-pass QA, Sonnet only for real implementation and hard debugging, and a deterministic Python state machine owning budgets, routing and agent ownership. A concrete answer to runaway orchestration costs.

Insulting Your Agents Backfires: Your Words End Up in the Source

After agents started failing tasks more often, the author dug into their project docs and found the agents had been recording exact quotes, including insults thrown at them, straight into source comments and historical notes. The takeaway is practical rather than sentimental: hostile input pollutes the context that later sessions read back.

Ticket-First Claude Code Workflow With Just Four Repo-Committed Agents

A setup refined over three weeks of daily use that cut 20 subagents down to four, kept in .claude/agents/ so they travel with the repo: a coordinator that only routes, a business analyst that turns ideas into tickets, and a senior engineer that owns the whole stack alone. Every unit of work is a markdown ticket committed before any code, and closing it git mv's the file into done/ in the same commit as the implementation. Worth reading if your agent roster has sprawled and you want the outstanding-work list to be just a folder.

md-agent: File-Based IPC to Point a Team of Claude Code Agents at One Goal

Orchestrates a team of Claude Code agents working toward a single goal, coordinating them through file-based inter-process communication rather than a daemon or socket layer. Because the coordination substrate is plain files, agent handoffs stay inspectable and version-controllable. A good fit if you want multi-agent orchestration without standing up extra infrastructure.

Measuring the Cost of Preferring Bash Over Read/Edit in Claude Code

A user tracked what happens when agents are nudged to do file work through Bash (cat, grep, sed, heredocs) instead of the native Read/Edit/Write tools, and saw ephemeral agent contexts grow 20-40 percent. Their breakdown: reading via Bash is a win, but heredoc edits ran about 819 tokens each against roughly 546 for a native Edit, because the payload carries both the old and the new text. Useful measured data before adopting a bash-first instruction of your own.

cuckcoder: Kotlin, Android and KMP Harness of Rules, Skills, Hooks and MCP

A complete AI coding harness aimed at Kotlin, Android, Compose, and KMP work, bundling rules, skills, agents, workflows, hooks, and an MCP server. Everything is tuned to the JVM and Android toolchain rather than left generic. A reasonable starting point if Claude Code keeps guessing wrong on your Gradle and Compose conventions.

translate-book-arxiv: arXiv Papers Into Book-Quality PDFs

Translates arXiv papers into book-quality PDFs using parallel sub-agents. It reads the LaTeX source rather than the rendered PDF, so equations and the paper's own numbering survive translation.

application-doc-toolkit: Fact Governance for LLM-Written Documents

Every claim in a generated document must trace to a verified source entry, a scripted lint gates each draft, and reviewers hold no write access. Demonstrated on resumes and cover letters.

requirement-orchestrator: Spec-Driven Decomposition With Evidence Gates

Turns a software request into independently verifiable units of work under one controlling agent, delegating across Claude and Codex with evidence-gated delivery. A Markdown-only methodology skill with no runtime.

search-visibility-audit: A Free Five-Category Site Visibility Audit

Grades a site across five categories, scores three dimensions, and triages every finding to a severity, a week and an owner. Free and complete as published.

harness-template: Agent-First Repo Template With Frontend Governance

An agent-first repository template covering AGENTS/docs governance, frontend engineering conventions (FSD, coding, testing, CI, review), AI tool and memory strategy, and a skill source directory. Ships with a CLI: npx harness-tool init.

hypoloop: Hypothesizer, Challenger and Verifier CLI Loop

A zero-dependency multi-agent CLI loop with three roles — hypothesizer, challenger, verifier — that runs on agy, codex or claude, whichever you have installed.

ai-second-opinion: Send One Document to a Panel of Models

Sends a single document to Spark, Codex, Gemini, Kimi, Qwen and others at once, highlights where they disagree, and mechanically verifies that each actually did the research rather than inventing sources.

OPS: An Operator's Shell Harness Template for Claude Code

An opinionated Claude Code harness template built around foreman orchestration, git-synced memory, session-survival discipline, a multi-agent fleet and a first-launch bootstrap.

auto-task: Turn Units of Work Into Shippable Code

An opinionated agentic workflow that takes well-defined units of work through to shippable code with minimal human input.

clybor-claude-tooling: A 19-Agent Adversarial Review Bootstrap

A drop-in .claude/ tree with a 19-agent adversarial review team, a Ralph Loop, dev-flow skills and an init script. Project-agnostic and ready to bootstrap a new repo.

maestro (abmach): Plan, Parallel-Implement, Test, Document

An Agent Skills bundle giving coding agents a four-stage workflow: plan, implement in parallel, test, then document. Works with Oh My Pi, Claude Code and OpenCode.

claude-multi-agent-dev: One Session as a Team, Coordinated by GitHub

A Claude Code template that splits one session into Lead, Frontend, Backend, UI/UX and QA agents coordinating through real GitHub issues and pull requests, with a local orchestration dashboard.

jckeen/dotfiles: One-Command Setup for Claude Code and Codex

A one-command jumpstart on macOS and WSL2 covering slash-command skills, a multi-agent review orchestra, safety hooks, multi-session tooling, a status line and auto-hygiene. Opinionated defaults so the setup is not something you have to remember.

waypost: A Markdown Project Vault With the Same Roles Everywhere

Keeps decisions, specs, epics, stories and a board as markdown in git, with identical agent roles in every harness. A harness-agnostic fork of ProjectStore.

coverloop: One Model Builds, Independent Models Review

A multi-agent coding loop where one model implements, independent models review from different angles, tests decide, and you hold the final gate. Privacy-enforced, anti-drift and self-improving.

Ask Claude What It Needs to Run Faster on Your Machine

Asking the agent directly what would speed it up surfaced stale Rosetta tooling, a Python on PATH missing zoneinfo, and a missing incremental type-check flag. Fewer errors more than raw speed was the payoff.

Why You Shouldn't Let Claude Set Your Mac's Clock to 4026

A cautionary account of running a suggested sudo systemsetup and date command without reading it, and the damage that followed. A concrete argument for reading agent-suggested privileged commands before pasting them.

Claude Code v2.1.259 Appends Co-Authored-By and a Session Trailer

A user reports a system-level attribution policy in v2.1.259 that overrides standing CLAUDE.md instructions against co-author trailers, and adds a Claude-Session line that makes commits externally linkable to sessions.

A Prompt Template for a Proper Pre-Launch Security Audit

A solo developer shipping a Next.js and Payload commerce app ran one large audit prompt in a fresh session with the dev stack running, and got back a findings report plus a session-by-session remediation plan. Two findings were serious enough to have delayed launch. Template included.

Two Ways to Count Output Tokens, Two Very Different Answers

Claude Code writes every session to JSONL under ~/.claude/projects/, and one assistant response can span several lines that each repeat the same usage block. Counting naively double-counts — the author got 59.5M one way and 20.6M the other, which matters for every third-party usage tool.

Routing by 'Does This Step Decide Anything?' With a Local 27B

A multi-agent routing matrix in pi.dev on a 200k+ LOC legacy app, classifying every task by whether it makes a decision rather than by difficulty. The author argues a local Qwen3.8-27B can absorb the non-deciding work that mid-tier models used to do, while frontier models keep the decisions.

Has Anyone Run Anthropic's AI-Native SDLC Playbook for Real?

A discussion of Anthropic's published AI-Native SDLC playbook, whose loop chains version-controlled artifacts — intent.md to spec.md to plan.md to code and tests to PR findings — each feeding the next stage. The thread asks for experience reports from real projects.

Auto Mode Tells Agents to Use Bash Instead of Read/Edit/Write

While investigating an agent stalled for eight hours on an approval prompt, a user found the auto-mode system prompt instructing the agent to prefer cat, grep, sed and heredocs over the dedicated Read, Edit and Write tools. Worth knowing if your permissions or hooks assume the dedicated tools.

A Handoff-Document Routine for Getting Opus 5 to Behave

Write a handoff document with a cheap model on low effort, clear context, switch to Opus 5 on high effort, then prime with CLAUDE.md and the handoff before any real work. The author also runs every root-cause analysis and plan past an advisor.

Keeping Claude Code Config Alive Across Replit Container Restarts

A short script that symlinks ~/.claude to a workspace-persistent directory, so logins and session context survive the Repl container being wiped on restart. No polling or copy-on-boot dance — every Claude read and write hits persistent storage directly.

rails-rocket-sheep: Rails 8 App Template Built for AI Coding Agents

A Rails 8 application template designed around agent work: a generated CLAUDE.md, one-rule-per-file conventions, and CI gates that enforce them. Targets Claude Code, Cursor, and Codex.

agent-chassis: Contract-First Orchestration for Long-Running Coding Agents

An orchestration layer built around scoped work records, local dispatch, review evidence, and enforcement provenance. Aimed at agent runs long enough that you need proof of what was checked, not just a final diff.

A verify Skill That Independently Checks What Claude Said Was Done

Written after the author spent two hours a day manually clicking through features that had green tests. The skill runs a separate verification pass against the spec, on the premise that the model which wrote the code also wrote the tests, so of course they pass.

Ratchets: Baseline Existing Debt, Fail the Build Only on New Debt

A senior engineer who has not hand-typed code all year describes the guardrails that kept agents from rotting the codebase. Existing debt is baselined and ignored; new debt or a worsening baseline fails, and the error hands the agent the exact line and fix without revealing that the baseline file could be edited.

Why Auto Mode Started Asking Permission for cat, grep, and rg in 2.1.257

Any Read(...) entry in permissions.deny — not just a wildcard, and in any settings file — triggers the new cd-compound-read check added in 2.1.257, which is why basic searches suddenly prompt in auto mode. The author diffed the 2.1.252, 2.1.258, and 2.1.259 binaries to confirm the cause, and removing the deny entry resolves it.

agent-friendly-web-stack: A Strict Web Stack Spec Agents Can Follow

A specification and verification toolchain for greenfield web products, deliberately narrow so an agent has fewer ways to go wrong. Ships the checks that prove a project still conforms.

houserules: Knowledge Base, Backlog, and Agent Workflow in One Repo

A repo-level convention set combining a knowledge base, a backlog, and a defined agent workflow, aimed at codebases built primarily by AI coding agents.

prismatic-majordomus: One Policy, Generated Instructions for Every AI Tool

A supervisory control layer that keeps a single policy, generates the per-tool instruction files from it, holds durable task state, and ships a doctor command that proves the enforcement you declared is actually wired up.

Two Months Building a Claude Code Workflow That Carries State Between Sessions

The author leaned on obra/superpowers and mattpocock/skills for a long time, but found they handled discrete tasks well and never covered taking a project from raw idea through design into production — no way to carry state between sessions, no framework for building a knowledge base out of actual work. Brainstorming a project spans days and multiple sessions, and context died at each boundary. Two months in, still building the thing that fills that gap.

revloop: Branch, PR, AI Review, Fix, Merge — On a Loop

A reviewer-agnostic loop that takes a branch through PR, AI review, fixes and merge, then repeats. Works with either Claude Code or Codex as the reviewer, so you aren't locked to one harness for the review step.

buildcrew: 11 Specialized Claude Code Agents With 9 Operating Modes

An auto-orchestrated team of 11 specialized subagents for Claude Code, switchable across 9 operating modes depending on what kind of work is in front of it. For people who want a preassembled agent roster instead of defining their own.

veriloop: Spec-Grounded Code Review and Repair Loops

Runs review-and-repair loops that are anchored to a spec rather than to the agent's own opinion of the code, for both Codex and Claude Code. The spec grounding is the point: it gives the loop a fixed target so it converges instead of churning.

PraxFlow: Composable, Evidence-First Engineering Workflows as Agent Skills

Engineering workflows packaged as portable Agent Skills, built around requiring evidence at each step rather than trusting the agent's claim that a stage is done. Composable, so you assemble the pipeline you need.

kickoff: Method Docs, Scaffolding and Spec-to-Board Scripts for Projects

A project starting kit with method documents, GitHub scaffolding and scripts that turn a specification into a populated project board. The core is stack-agnostic with a thin layer added per stack.

100 Rounds of Subagent Bug Hunting and It Still Finds New Bugs

A simple loop: point it at a page, and each round spawns a fresh batch of subagents to crawl it for bugs. About 100 rounds and roughly 30-40 minutes per round in, it has never once come back empty. Raises a real question about when an agent bug hunt is actually done versus just generating findings.

ai-software-architect: ADRs and Architecture Reviews as a Claude Plugin

An architecture documentation framework built around ADRs and structured reviews, with a pragmatic mode for when full ceremony isn't warranted. Now packaged as a Claude Code plugin for one-step installation.

Source Context Is Not Runtime Context: The Frontend Gap in Agent Coding

Agents explore repos well but can't see runtime state, so for UI work they guess at rendered output, the selected element, console and dev-server logs, the current route and the HMR result after an edit. Playwright helps but costs a lot of tokens and is non-deterministic. Written by the author of Frontman, which is their attempt at closing the gap — the framing of the problem stands on its own.

loop-flow: An SDD Workflow Skill With Async Verification for Fake Done

A spec-driven development workflow skill with loop-engineering async verification, built specifically to catch the case where the model believes it implemented something it didn't. The author's use case: write the plan, hit enter, walk away. Note it's token-hungry — they suggest planning with a strong model and executing with a cheaper one, and it ships without per-platform adaptation.

A 7-Month Claude Code Setup: 19 Hooks, 36 Skills, All From Real Incidents

A full public writeup of a setup built over 151 days across ~140 projects, structured as five layers: instructions, hooks, skills/plugins, agents and model routing, and the memory/learning loop. Every hook is introduced by the incident that produced it — a subagent killing a real Notepad with 40 unsaved tabs led to blocking kills by image name; a backgrounded dev server leaking 663 tsserver children and 13.6 GB of RAM led to a watchdog that reaps orphans. Repo is public.

terminal-first-goal-loop: Goal-Driven, Verifiable AI-Assisted Development

A terminal-first workflow that keeps AI-assisted development anchored to explicit goals with verification at each step, rather than an open-ended chat that drifts.

War Story: Reviewing AI PRs When the Author Already Left the Building

A reviewer's account of why AI-generated PRs are harder to review than a teammate's, even when the diff is smaller: with a human author you could ask why this way, what they tried first, which edge cases they weighed — half of review was loading their reasoning into your head. With an agent PR, that context never existed for anyone. A clear articulation of a problem most teams are now hitting.

agentnizer-cookbook: A 14-Agent Pipeline From Plain English to Reviewed PR

A 14-agent code generation pipeline that takes a plain English request and ends at a reviewed pull request. The authors describe it as production-validated and LLM-agnostic in shape. MIT licensed.

Beating the 20x Plan Limit: Fable Plans, Cheaper Models Execute

One approach to hitting session limits an hour in on the 20x plan: use Fable 5.1 purely as the planner, never letting it touch code, then hand the strict plan to Opus 5, 4.8 or 4.6 to implement. The author's claim is that with a good enough plan those three perform about the same, so the expensive model's budget goes entirely into planning.

loam: A Copier Template That Bootstraps Agent-Optimized Project Setups

A Copier template that stands up AI-agent-optimized project scaffolding: layered context routing, a curated skill set and an enforced validation gate, kept in sync across projects as the template evolves.

multi-agent-playbook: Field-Tested Methodology for Multi-Agent Collaboration

A bilingual (Chinese/English) playbook of multi-agent collaboration patterns drawn from real projects: splitting design work from execution, governing which skills agents may use, prompt engineering, and general engineering discipline. Aimed at people running several agents on one codebase and hitting coordination problems.

TRACE: Auditing Decision Provenance in AI-Assisted Science

A protocol for recording and auditing which decisions in a scientific workflow came from a human and which came from an AI agent. Targets reproducibility and review needs in research settings. Early-stage, but the provenance problem it names applies well beyond science.

codex-claude-companion: Read-Only Opus Review Lanes Inside Codex

A Codex-native plugin that calls Claude for code review in read-only lanes with evidence citations required for each finding. Keeps the reviewing model separate from the writing model. Relevant if you run Codex as the author and want a second opinion that cannot edit.

musterd: Persistent Agent Teams Across Any Harness or Model

A shared communication protocol that lets agents and humans form persistent teams spanning different harnesses, frameworks, models, and surfaces. Aims at the case where your agents live in incompatible tools and cannot address each other. Ambitious scope; worth watching if you run mixed-vendor agent setups.

drydock: Wave-Based Parallel Execution With Disjoint File Ownership

A plan-first workflow for Claude Code: write a rigorous plan document, then execute it in waves of subagents where each owns a disjoint set of files. Conformance gates check the result against the plan and a reconcile loop fixes drift before anything merges.

productizer: Requirements Tracking Where a Contradiction Stops the Work

Keeps one living spec per product and classifies every new intent against everything already agreed. When a new request contradicts a prior decision, the work halts instead of quietly merging conflicting requirements.

A Protocol and File Channel for Codex and Claude Code on One Mission

Two skills plus a file-based message channel that let Codex and Claude Code work the same task without overwriting each other. Defines a handoff protocol so each agent knows what the other has claimed.

specbind: Keep Durable Specs Bound to Delivery From Intent Through Release

Maintains the link between a written specification and the agent-assisted work that implements it, across the whole path from intent to release. Aimed at stopping specs from becoming stale artifacts once implementation starts.

Building a 4.7k-Star OSS Tool With Claude Code Without Knowing Python

A detailed retrospective on building sqlit, a lazygit-style SQL TUI, entirely through Claude Code with no prior Python experience. Covers the workflow that kept the code from becoming slop, and how asking the agent where to launch led to a Hacker News front page.

multi-review: Fan a PR Diff to Several AI Reviewers and Reconcile One Report

Sends a pull request diff to agy, codex, copilot and cursor in parallel, adds Claude's own pass, then de-duplicates and severity-ranks the findings into one line-validated review. Installable as a Claude Code plugin.

pairmark: Race Claude Code Against Codex on the Same Task in Your Own Repo

Runs both agents on an identical task in your repository, collects evidence first, has blind judges score the results, and emits one shareable report. A way to answer which tool is better for your codebase rather than a benchmark's.

Running DeepSeek in One Claude Code Session and Opus in Another, Talking

A short report on pointing one Claude Code session at DeepSeek while keeping another on Opus, then using session messaging to make them collaborate. A cheap way to keep the harness while mixing in cheaper models when limits bite.

codeservo: A Deterministic Control Loop Where Gates Decide, Not the Agent

Wraps AI-generated changes in a control loop: the agent proposes, and gates, sensors and an independent review decide whether the change lands. Every run leaves verifiable evidence of why it passed or failed.

claude-codex-duo: Blind Two-Model PR Review and Structured Debate on Disk

Pairs Claude Code and OpenAI Codex adversarially: each reviews a PR without seeing the other's findings, then they debate in a structured format with the whole exchange written to disk as evidence.

disciplined-code-changes: Guardrails Against How AI Code Assistance Fails

A Claude Code plugin encoding engineering guardrails aimed at the specific ways AI assistance commonly goes wrong — scope creep, unverified claims, and silent rewrites. Prescriptive rather than a general style guide.

Fanning a Document Harness Into Parallel Agents, and the Token Cost Question

A report on parallelizing the discovery phase of a document-generation harness into separate geometry, content and asset agents. The key fix was joining on actual completion rather than file existence, after a pipeline continued on a half-written file and produced valid-looking garbage.

scout-plugin: Daily Briefing That Cross-Checks Slack, Gmail, Calendar and Linear

An autonomous Claude Code briefing that pulls from Slack, Gmail, Calendar, Linear and GitHub and cross-references them, so items that appear in one place but not another get flagged. Emphasis is on trusting what it surfaces, not just summarizing.

dev-platform: Agent-First Platform for Specs, Routing, Verification and Release

Ties together specification writing, coding-agent routing, isolated work environments, verification, GitHub delivery, releases, and managed rollout as one platform rather than separate scripts.

herdr-hybrid: Smart Model Leads, Cheap Models Do the Work in Parallel Windows

A Chinese-language hybrid orchestration setup for Claude Code on herdr: one config for gateway, keys and models; the leader decomposes, accepts and reviews; headless workers implement in parallel, each in its own herdr window.

A Parallel Orchestrator Where Truth Comes From the Diff, Not Agent Reports

Four rules for a parallel task orchestrator, the sharpest being that a subagent claiming it changed four files is making a claim, not providing evidence — the repository is the only source of truth. The author is openly unsure about the rule that refuses to parallelize.

The Always-On Linux Box Setup That Ends Carrying Your Laptop Half-Open

A practical writeup on moving long Claude Code sessions off the laptop: why Caffeine and cloud sandboxes both fail, and what a plain always-on VPS plus a bit of glue actually needs to feel like your local machine.

Teknesyum-Core: Token-Aware Multi-Agent Orchestration Plugin for Claude Code

An orchestration plugin that factors token budget into how work is split across agents, rather than fanning out and hoping. Relevant if parallel agents are what is draining your weekly limit.

harness-lens-reviewer: Grade an LLM Reviewer Against Labeled Specimens

A meta-evaluation harness that scores how well an LLM review pass actually detects planted defects, using labeled specimens. Answers whether your reviewer agent is finding anything, not just producing findings.

Declare Your Subagent Model or Fable Will Silently Spawn More of Itself

Subagents inherit the parent model by default, so a Fable session quietly runs multiple Fable subagents and burns the weekly allowance fast. Setting the subagent model explicitly in settings.json — and again inside skills — is reported as the single biggest usage reduction.

delegation-pipeline: Send Grunt Work to Free Models, Keep Claude for Thinking

Offloads mechanical work from your paid Claude Code session to free or cheap OpenAI-compatible models, so the metered session spends its budget on reasoning rather than typing. Zero dependencies.

Does Model Diversity Help Multi-Agent Verification? 720 Runs Say Maybe Not

A pre-registered experiment testing the common intuition that confirmations from different base models are worth more than confirmations from the same one. The author ran 720 evaluations, failed their own kill condition, and published the design asking where it breaks.

Keeping Test Runs From Eating All Your Tokens During Bug Fixes

A writeup of how uncontrolled test output during debugging loops drives token burn, and what changed after the author identified and fixed it. Reported as a major reduction in consumption, particularly during bug fixing.

ai-engineering-playbook: Rules and Role Separation for Teams in Production

A practical playbook for AI-assisted engineering in production codebases, covering rules, separation of roles between human and agent, and guardrails. CC BY 4.0, written around Cursor and Copilot but largely tool-agnostic.

tagteam: Claude and Codex Plan, Implement, Cross-Review and Merge PRs

A multi-agent workflow for Claude Code where Claude and Codex split planning and implementation, review each other's work, and drive the pull request to merge. Full loop rather than review-only pairing.

Clean-Room README Testing With Two Claude Code Sessions

Claude Code is too good at working around a broken README — it reads package files, searches source, and infers intent, which makes it a terrible onboarding test. The fix is an installer session given a disposable clone and one rule: follow only the public README, adapted from the gr-readme skill.

jaeger: Prompt-First Durable Workflows Across Native Coding-Agent Harnesses

Runs durable workflows defined in prompts across different native agent harnesses, so a long multi-step process survives interruption. Harness-agnostic by design.

groundwork (2005sojid): A Gate That Cannot Be Silently Green

A portable working set for agent projects: rules enforced by actual checks, a gate designed so it cannot pass without doing the work, and a script that measures how sessions actually went afterward.

Coordinating Parallel Claude Code Sessions With Close-Out Reports and a Merger

A rebuild of a production app using a fleet of parallel Claude Code sessions on independent feature branches, each ending with a close-out report, plus one dedicated coordinator session that verified and merged to main. Includes what broke and what the author would change.

convoy: Decompose Work Into a Governed PR Series With Per-Spawn Economy

Breaks a large piece of work into a series of pull requests, drives a coding agent to implement each under an explicit budget, gates and integrates them, and records the cost of every agent spawn. Governance and measurement rather than raw throughput.

Mex: Keeping Markdown Context Files From Rotting as the Codebase Moves

Architecture notes, conventions, runbooks and CLAUDE.md all decay while agents keep reading them with full confidence. Mex is an open-source attempt at markdown context that maintains itself against the code it describes.

co-evolution: Two Agent Roles Bounce a Document Until It Converges

Structured refinement where two agent roles pass a file back and forth using explicit disagreement markers until the disagreements are resolved. Agent-agnostic and runs from any terminal.

okl: typed, verifiable engineering lessons injected into coding agents

Org Knowledge Layer treats team memories like tests rather than freeform notes — lessons are typed and verified before an agent starts work. It briefs agents fail-closed, gates verification on drift, and records A/B receipts in-repo so you can see whether a lesson actually changed outcomes. Useful for teams trying to stop repeating the same corrections across agent sessions.

Running one Claude Code session across all repos from a shared root folder

A developer describes starting every session from a single ~/code root that contains all work repos, giving one agent visibility across services and infrastructure instead of one agent per repo. Work is broken down epic to feature to sub-task, with a worktree per task and cleanup or custom-summary compaction around 300-400k tokens. A concrete counterpoint to the usual one-repo-one-session advice.

Fable 5.1 rewrites whole files by default, so prompt it for targeted edits

A warning that Fable 5.1 prefers full-file rewrites over targeted edits, which burns output tokens on small changes, and that its prose runs longer than Fable 5. The fix from Anthropic docs is an explicit system-prompt line telling it to prefer targeted edits. The thread also notes it may need a nudge not to end its turn early on long async work.

Fable 5.1 can spawn forked agents that ignore your default subagent model

A user on the 20x plan hit 100% of the 5-hour limit in 20 minutes because Fable 5.1 spawned four forked agents each running Fable 5.1, despite the default subagent model being set to Opus 5. Fable 5 rarely spawned forks at all. Worth checking your session usage if you have just switched models.

Non-obvious Fable 5.1 SWE findings from the 212-page system card

A careful read of the Fable 5.1 system card surfacing details the headline benchmark table hides. Notably, higher reasoning effort scores worse on FrontierCode Main (50.9% at medium vs 50.3% at max) because the model starts making unrequested scope-creep edits, which the benchmark grades down even as task correctness improves. Adding a brevity instruction reduced the effect.

delegate-kit: One delegation policy for Claude Code, Codex CLI and T3 Code

A single delegation policy shared across three agent CLIs, covering role-based headless workers, worktree locks so parallel workers do not collide, and cross-vendor review where one tool checks another. A safety-gate hook backstops the whole thing. Aimed at people running several agents at once who want consistent rules.

claude-vibe-squad: One Chat Orchestrating Five AI Models via Subscriptions

A plain-English orchestrator called Chrono that fronts five models (Claude, Codex, Gemini, Kimi, Grok) plus specialist roles, so non-technical users never pick a model or memorize slash commands. Runs on subscriptions rather than API keys. Latest revision adds Grok and reworks its bounty mode.

Making Claude CLI Actually Load Karpathy-Style Knowledge Files

Claude CLI silently ignores knowledge-file includes declared in agent and skill files, which breaks the bite-sized Obsidian knowledge approach. The author describes how they get per-agent knowledge to load on demand instead of pulling the whole vault into context.

A GAN-Inspired Prompt Pattern for Matching a Curated Writing Style

A pure-prompt technique: the orchestrator extracts rules of good output from curated examples, one subagent authors against those rules, and a second subagent acts as discriminator. Useful for making skills or prose match a reference corpus without fine-tuning.

Fable Used via /advisor Doesn't Count Against Your Fable Quota

A usage finding: selecting Fable as the advisor through /advisor appears not to draw down the weekly Fable quota. The poster has been pairing Opus with a Fable advisor and reports the advisor catching real issues often enough to be worth it.

Auditing Anthropic's Devcontainer Firewall and Building a Tighter Sandbox

A close read of Anthropic's devcontainer firewall finds UDP 53 open to any server, TCP 22 open to any host, no ip6tables rules, and the firewall living inside the same container the agent can reach. The post lays out an alternative setup for running Claude Code autonomously without that trust gap.

Is intent.md the Next Standard Alongside CLAUDE.md, plan.md, and spec.md?

Discussion of Anthropic's AI-native SDLC playbook and its dedicated intent.md file. Frames it as the successor to the metaprompt era of eliciting intent, and asks where it fits among the file conventions teams already maintain.

Running Codex Against Claude Code on One Codebase, With a Judge

A VSCode setup where Claude Code drives Codex CLI as a second provider, work is split into engineer/designer/researcher/security/judge roles, and a judge agent picks the winning solution at each step. Both connect through Max-tier accounts rather than API keys.

10,727 Messages of Claude Code History, Counted and Analyzed

The author parsed their full Claude Code history across 343 sessions and tallied both sides: 33% of their own messages contained a correction or complaint, against 1,897 instances of "you're right", 785 admissions of being wrong, and 916 admissions of guessing or inventing something. A concrete look at where agent sessions go wrong.

A Handoff Bundle That Cuts Session Resume From 20k Tokens to ~640

Every session began by re-reading the README, config, touched files, and tests — 20k to 60k tokens of re-orientation before any work. This Python package saves findings, open questions, decisions, and evidence anchors pointing at exact files and commits, then loads that bundle instead of re-reading the repo.

changerail: OpenSpec Artifacts, Review Gates, and Release Automation

An open toolchain for AI-assisted development that ties OpenSpec artifacts to board-driven delivery, reusable agent skills, review gates, and release automation. Covers the path from spec to shipped release rather than one stage of it.

agency: Declarative Arch/CachyOS Bootstrap as an Agent Environment

Declaratively bootstraps an Arch or CachyOS workstation into an operating environment for Codex, Claude Code, and Pi, bundling reusable skills and development workflows with the machine setup.

akos: Structuring Tools So Agents Can Safely Operate Them

A method whose unit is the tool rather than the skill — you describe the systems you depend on in a form that lets agents operate them without improvising. Aimed at the gap between a skill knowing what to do and an agent safely touching production tooling.

nullius: A Ceremony-Free Agent Methodology With Costed Claims

Nullius in verba, applied to coding agents: top-tier judgment stays hands-on, Haiku scouts absorb the bulk of the work, and mechanisms get quoted rather than claims trusted. Ships seven benchmarks, six self-refutations, and a token bill attached to every claim.

ttt-workflows: pr-review, sec-audit, and trp as Claude Code Skills

Three engineering workflows packaged as skills — PR review, security audit, and TRP — distributed through a git-backed plugin marketplace with its own marketing site.

spec-flow-plugin: A Feature Ships Only When a Real Test Proves the Spec

A spec-driven multi-agent pipeline where lint, tests, and requirement traceability all run outside the model, so shipping depends on a test that actually executed rather than on the agent's claim that it passed. For Node projects.

logbook: Git-Backed Threads That Persist Claude Work Across Sessions

A Claude Code plugin that records your work into git-tracked threads so context survives between sessions. Instead of re-explaining what you were doing, you resume a thread and the history comes with it. Because it is git-enabled, the log lives alongside the code it describes.

agent-loop: Schedule Autonomous Coding Agents Across Provider Accounts

A scheduler that runs autonomous coding agents on a timetable and spreads them across multiple provider accounts, executing each as a herdr agent in its own pane. It targets the case where you want long-running unattended work without exhausting a single account quota. Pairs with herdr for visibility into what each agent is doing.

nullius: Machine-Verifiable Claims for Design Docs and Agent Proposals

A format and checker for citations inside design docs and agent-written proposals, so each factual claim points at something CI can re-verify. When a claim drifts out of sync with the code it cites, the check fails. Targets the problem of agent-generated documents that sound authoritative but quietly go stale.

espalier-engineering: Encode Your Codebase's Patterns as Rules and Skills

Discovers the conventions your codebase actually follows, then encodes them as Claude Code rules, skills, agents, and hooks plus a guided pipeline. The goal is generated code that lands inside your conventions on the first attempt rather than after several correction rounds. Aimed at teams tired of repeating the same review feedback.

Nested CLAUDE.md Files Written by Older Models Can Hurt Opus 5

A developer with thousands of hours of autonomous Claude Code runs found Opus 5 struggling on an established workflow. The cause turned out to be nested CLAUDE.md files authored for older models, whose accumulated hedges and workarounds fight the newer model. Worth reading if you carried a mature config forward across model generations.

Repo That Teaches Claude Code Your Preferences by Observing Sessions

An open-source repo you drop alongside your project so Claude Code observes how you work and accumulates your preferences over time. The stated goal is agent-portable, self-owned preference storage rather than platform lock-in, plus an optional shared pool of contributed best practices. Author is asking for testers and contributors.

travel-planner: Seven Agents Plan a Trip and Publish It as a Site

A multi-agent travel-planning engine for Claude Code where seven specialist agents research, plan and validate a trip, then publish it as a self-contained shareable site. A readable example of specialist-agent decomposition on a non-coding domain.

pact: Multi-Agent Orchestration CLI With Worktrees and Test Gates

A CLI that isolates Claude Code, Copilot, Codex, Gemini and Antigravity in separate git worktrees, preps dependencies, then lands their work back with a risk-sequenced, JSON-aware, test-gated merge-all. The author flags file-claim coordination as advisory and not yet reliable under concurrency.

Claude-ExternalPentest: Agent Pipeline for Authorized External Pentests

A set of Claude Code agents that walk an authorized external penetration test through scope, recon, enumeration, attack planning, exploitation and reporting, structured around PTES and OWASP WSTG. Intended for engagements you have written authorization for.

Overnight Coding-Agent Orchestrator Built in Claude Code on a $20 Plan

After two months of manually running propose to implement to validate to merge every night, the author automated the loop into an overnight orchestrator built entirely inside Claude Code on the $20 Pro plan. The writeup covers the specific failure modes that shaped it: tests quietly deleted instead of fixed, processes that never died, flaky Playwright runs.

telos-sdd: Git-Native Contract Keeping Developers and Agents Aligned

A Git-native contract describing what the software should do, kept in the repo so developers and coding agents share one source of intent. A spec-driven-development approach where the spec lives under version control alongside the code it governs.

cuttings: Turn Git Worktrees Into One-Command Dev Environments

Turns git worktrees into isolated, one-command development environments, built specifically for running AI coding agents in parallel. Handles the setup that normally makes worktree-per-agent workflows tedious.

Worktree-per-Ticket, Cron Harnesses, CLAUDE.md as API: 1,790 PRs

The setup that converged after shipping a roguelike deckbuilder on iOS and Android with Claude writing effectively all the code across four months and ~1,790 merged PRs. Root plus per-folder CLAUDE.md files act as the real interface, encoding architecture constraints agents build inside; paired with worktree-per-ticket isolation and three cron harnesses.

Three Tiers Instead of Six Agents: Cutting Planning Overhead in Agent Pipelines

The author found their spec writer, spec reviewer, rewriter, planner and plan reviewer were burning most of the model budget before any code got written. They replaced the pipeline with three tiers: FAST (brief to code to tests), STANDARD (mini spec, one approval, code), and FULL for genuinely risky changes. A useful corrective for anyone over-engineering multi-agent orchestration.

Ai-workflow: A Deterministic Context Layer in Front of Coding Agents

An open-source workflow that stops agents from burning context rediscovering a repository before every change. Rather than another agent framework, it puts a deterministic navigation layer in front, leaving Claude, Codex, Gemini, Cursor or Copilot to do the reasoning. Ships three execution paths for different task shapes.

Deleting All Inline Documentation to Stop Agents Brain-Dumping Into Comments

After no amount of instruction kept Claude from over-documenting inline, the author stripped inline docs from the codebase entirely and added a flat "no inline docs" rule to AGENTS.md. The pass doubled as a readability and self-documentation cleanup. Reported result: better-reading code, less stale context for agents to trip over, and lower context load overall.

kstrl: A Software Factory That Only Stops When Independent Checks Agree

Hand it a spec and it plans, builds, then measures the result with checks the agent did not write, feeding the gap back into the next iteration. The loop terminates only when independent verification agrees, keeping you on the loop rather than in it. A serious take on closing the self-assessment gap.

symphony-async: One Automated Workflow Across Commits, Tests, Releases and Docs

A modular Claude Code skill ecosystem that orchestrates commits, testing, releases and documentation as a single development workflow. Each piece stays separable, so you can adopt parts of it. Aimed at collapsing the usual end-of-task ritual into one flow.

shell-team: A Spec-Driven Dev Team With an Independent Codex Reviewer

Gives Claude Code a PM, Tech Lead, Engineer and QA behind explicit handoff gates, plus a reviewer running on Codex so the review isn't done by the same model that wrote the code. The cross-model review is the differentiator. Gates are explicit rather than advisory.

LexForge: Nine Skills and Gates the Agent Cannot Skip

A spec-driven pipeline combining OpenSpec artifacts with superpowers discipline, enforced by a CLI rather than by prompt instruction. Because the CLI holds the gates, the agent can't talk its way past them. Nine distinct skills cover the pipeline stages.

oddyssey: Observability-Driven Development for Coding Agents

A CLI toolbox letting agents observe local runs against an OpenTelemetry/Grafana stack — or remote runs on any OTel backend — and feed what they see into the next spec-driven improvement loop. Closes the loop between what the code does at runtime and what the agent plans next. A genuinely different angle on agent feedback.

claude-code-openbsd: Running Claude Code on OpenBSD With pf, doas and pledge

Runs Claude Code via vmd plus Alpine Linux and Docker, using OpenBSD's own security model as the real perimeter rather than trusting container isolation alone. A thoughtful sandboxing approach for people who want a hard boundary around an agent. Documented setup rather than a package.

roscoe: A Single Binary Running Your Claude Code Fleet

Three-tier orchestration driving Claude Code alongside GLM-5.3-Flash subagent swarms, all from one binary. Mixing a cheap fast model for swarm work with Claude for the top tier is a sensible cost structure. No runtime dependencies to install.

clankbrain: Memory and Workflows for Claude Code That Compound Across Sessions

Persists what a session learned so later sessions build on it instead of starting cold. Pairs memory with workflows so recall actually changes behaviour. Aimed at long-running projects.

nix-claude-code: Declarative Claude Code as Composable home-manager Modules

Manages plugins, marketplaces, skills, hooks, MCP servers and permissions declaratively in Nix, reproducible across macOS and Linux. The whole agent configuration becomes reviewable, versioned and rebuildable. A strong fit for anyone already on home-manager.

claude-dispatch: Parallel tmux Sessions With a Watchdog and Dependency DAG

Dispatches tasks across multiple Claude sessions in tmux, with auto-retry and a dependency DAG so ordered work still parallelizes. Born from running 13 investigations in 3 hours instead of 13 hours. The watchdog handles the sessions that stall.

specstamp: A Local-First Spec-Driven Development CLI With Acceptance Evidence

Keeps structured requirements, design, tasks and acceptance evidence so agent-assisted development stays traceable and resumable. Targets Codex, Claude Code and other coding agents. Documentation is in Chinese.

ihudak-claude-plugins: A Full Feature Lifecycle Gated by Opus Reviews

Runs idea to Value Increment to ARD to spec to design to Epics to implementation to docs to release notes, with an Opus review gating each stage. Tracks what every feature costs in dollars by phase, role and model, and captures friction in-flight so the workflow improves itself. Unusually complete cost accounting.

hydra-framework: Repository-Contained Infrastructure for AI-Assisted Engineering

Keeps the whole agent setup inside the repository so it travels with the code across Codex, Claude and other providers. Nothing lives in a personal dotfile the next contributor doesn't have. Provider-agnostic by design.

agent-loops: Worker Plus Adversarial Verifier With Hard Gates and Auto-Retry

Deterministic loops pairing a worker agent with an adversarial verifier behind hard quality gates, retrying automatically and escalating to a human when it can't converge. File-based with zero dependencies and a one-click on/off switch. Works with Claude Code, Codex, Cursor and Kimi.

ClaudeHarness: Review Subagents, Model Routing and Its Own Meta-Prompts

A curated harness combining spec-driven review subagents, model-routing rules and self-maintenance skills. Notably it publishes the meta-prompts used to generate the harness itself, so you can regenerate rather than fork. Useful as a reference configuration.

personal-ai-os: The Public Architecture of One Developer's Private AI OS

Documents how the author runs durable, high-agency collaboration with AI agents, publishing the architecture without the private contents. Useful as a worked reference for designing your own system. Architecture document rather than installable tooling.

ZenonEl/ephemeris: Hand Off Source Addresses, Not Lossy Summaries

Issue-based daily handoffs where sessions exchange pointers to where information lives rather than lossy summaries of it. Ships as a Claude Code plugin and a Codex skill. Addresses the compounding-distortion problem in summary-based handoffs.

claude-code-development-harness: An Interview-Built, Project-Specific Harness

Inspects a blank folder or existing repo, interviews you about what it can't infer, then installs a harness tuned to that project — context budget, work graphs, capability tiers and an agent session runtime. Adapting to the project beats a one-size template. Marketplace plugin.

bergant-workflow: A Claude Code Plugin That Won't Let the Model Skip Steps

Enforces workflow step completion rather than trusting the model to follow a documented process. Simple premise, addresses a very common failure. Installs as a plugin.

claude-code-orchestration-ko: A Korean Guide to Multi-Agent Orchestration

A practical Korean-language guide to running Claude Code multi-agent orchestration solo, with three free preview chapters and templates. Non-English orchestration material is scarce. Templates are usable independently of the book.

agentic-dev: Turn a Checked-In plan.md Into Reviewed Pull Requests

Three cron-driven stages — slice into issues, write failing tests, then implement until green — each running Claude Code or Grok in a disposable Docker container. Test-first by construction, with human review as the only merge gate. A well-shaped answer to unattended agent development.

ai-engineering-workspace: One Workflow Across Four Coding Harnesses

A portable persona canon, process skills and safety guardrails kept in sync across four harnesses by design rather than by manual copying. Sync-by-design is the hard part most multi-harness setups get wrong. Provider-neutral.

maddog: Advisor-Executor Agent Universe for Claude Code

A Claude Code agent system built around an advisor/executor split, with a family of executors tiered by how much judgment each is trusted to exercise. Includes a product-engineering pipeline plus gated skill-authoring and session-mining skills. Useful if you want a structured multi-agent setup rather than ad-hoc subagent calls.

agent-operating-system: Operating Model for a One-Human AI Coding Team

A written operating model — not a tool — for running AI coding agents as if they were a small team with a single human owner. Covers how work is assigned, reviewed, and accepted when most of the output comes from agents. Worth reading if your agent setup works technically but the process around it does not.

Load-Bearing Words: Single-Term Concepts That Sharpen Agent Prompts

A collection of 101 loanwords and terms that each compress a useful engineering concept into one word, curated for use inside AGENTS.md and CLAUDE.md. The author uses honte (the solid, correct move) and kakou (heat control) as positive directives, while banning pokazukha, aktionismus and muda. The idea is that a single dense word steers the model better than a paragraph of explanation.

The Stopping-Condition Problem in Agent-Driven Code Review

A discussion of the builder/reviewer agent loop and why it rarely terminates on its own: a competent reviewer can always surface another edge case, weaker test, or cleaner abstraction, and many of those findings are genuinely real. Raises the practical question of what stopping rule to use when 'review until nothing is wrong' never converges. Useful framing for anyone running automated review passes.

deepseek_herdr: DeepSeek as Commander of a Claude/Codex Agent Team

A multi-agent command plugin native to the DeepSeek harness that opens and directs a team of claude, opencode, and codex agents. Provides live visibility into what each agent is doing, coordinated through shared memory and a task board. Chinese-language project.

orchestrator: A Containerized AI Team for a Company of One

You state a goal and a team of agents assembles around it, splitting the work into slices you approve one at a time, then writes code, runs your tests, reviews the result, and opens a pull request. Every agent runs in its own container, so a destructive command hits the container rather than your machine. Aimed at solo developers wanting team-shaped process without a team.

tiered-agent-orchestrator: Strong Models Decide, Economy Models Execute

Routes decision-making to capable models and mechanical execution to cheap ones, with state persisted in the repository so long-running engineering work survives session boundaries. A concrete implementation of cost-tiering rather than a single-model loop. Relevant to anyone burning limits on work that does not need the top model.

phasekit: Run a Long Refactor as Reviewable Unattended Sessions

Splits one plan into phases, runs each phase as a headless Claude Code session on its own git branch with one commit per task, and requires gates to pass green before every commit. The runner survives usage limits, standby, and reboots, so a multi-hour refactor continues across interruptions. Designed so the resulting history is actually reviewable rather than one opaque mega-diff.

PAAD: Bringing Established Software Practices Up to AI Speed

Argues that the practices that made software work did not stop working, they stopped keeping pace, and adapts them for AI-assisted development. From Ovid, a long-time software engineering writer. A methodology repository rather than a tool.

Riftbook: Tools and Reusable Systems for Vibe-Coded Apps

A collection of prompts, workflows, and practical patterns aimed at replacing guesswork with reusable systems when building apps largely by prompting. Reference material rather than an installable tool. Useful as a starting point for building your own conventions.

agent-smith: An Agent That Propagates Improvements Into Other Agents

Mines your session history for lessons and audits your existing agent definitions for staleness, then opens pull requests with fixes. Treats agent configuration as code that should be maintained rather than written once and forgotten. Novel take on keeping a growing agent fleet consistent.

claude-reasoning: DAG Orchestration With Structured Contracts

A graph-based reasoning pipeline for Claude Code where steps are arranged as a DAG and each node exchanges data through a structured contract. Replaces free-form chaining with explicit dependencies and typed handoffs. For multi-step reasoning tasks that need reproducibility.

ctx-core: Obsidian-Backed PRDs for Unsettled Decisions, Lean Execution for Settled Work

Splits work by certainty: unsettled product decisions get a PRD stored in Obsidian, while settled technical work runs on a lean execution path. Shared across Claude Code, Codex, and OMP. Prevents heavyweight process from being applied to work that no longer needs it.

mergex: Deliver Agent Work to the Repo With the Diff Pre-Triaged

The final stage of the Expx method: one branch per unit of work, one commit per task, and a diff already classified by where human attention is actually worth spending. Focuses the reviewer instead of presenting an undifferentiated changeset. Portuguese-language project.

agent-workspace-starter: Governed Workspace Template With Session Discipline

A minimal Claude Code workspace template that ships orient/wrap session discipline, task capture, a lessons-learned loop, and two safety hooks from day one. It is meant as the starting scaffold for a new agent-driven repo rather than a full framework. Good if you keep rebuilding the same CLAUDE.md and hook setup for every project.

delivery-kit: Session Handoff and Idea-to-Reviewed-PR Plugins

Two Claude Code plugins: one hands a session off to a fresh context before the current one runs out, and the other drives a single feature from idea through to a reviewed pull request. They address the two most common long-session failure modes — context exhaustion and unreviewed output. Installable as a pair or individually.

phases-oss: Phase-Based Runner With an Adversarial Reviewer Gate

A pure-Python, zero-dependency workflow runner that splits agent work into bounded phases, requires deterministic proofs to advance, and runs an adversarial reviewer that never passes by default. The design forces the agent to earn each phase transition rather than declaring itself done. Notable for having no dependencies at all.

keel (Bhargs24): AI Founding Team That Plans and Builds a Product

An open-source product builder that runs an idea through simulated business, market, product, design, architecture, QA, and security roles, then builds it out using Claude Code or Cursor. The aim is a shipped production-grade product from one prompt-level idea. Broad in scope; useful mainly as a reference for multi-role agent orchestration.

infoseek: Multi-Source Research Pipeline With Contradiction Detection

An end-to-end content research workflow: sniff multiple sources, gate them through a four-dimension scoring filter, deep-crawl what passes, detect contradictions across sources, then emit a structured report and archive it long-term. The cross-source contradiction check is the distinguishing step. Documentation is in Chinese.

moot: Claude Code, Codex, and Copilot Debate While You Rule

Puts three CLI coding agents into one shared council where they debate a decision over MCP, and a human casts the final ruling on every outcome. Runs as a terminal UI using the CLI subscriptions you already have, so no API keys are needed. A concrete take on multi-model deliberation with the human kept firmly in the loop.

portfolio-automation: Scheduled Cloud Routines That Keep a Portfolio Site Current

Claude Code skills wired to scheduled cloud routines that automatically update a GitHub Pages portfolio — refreshing project entries and work-experience sections without manual edits. A small, readable example of using scheduled agent runs to maintain a live site.

ops-kit: The Generic Skeleton of a Personal Claude Code Ops System

The infrastructure behind a personal Claude Code operations setup, published with all the private data stripped out: a SQLite source of truth, search over it, hooks, an MCP server, a learning loop, and a task manager. Meant as a starting skeleton for building your own agent ops system rather than a product to adopt as-is.

continuo: Orchestration Layer Tying Claude Code to GitHub Projects v2

An orchestration system that wires Claude Code together with OpenAI symphony, herdr, and GitHub Project v2 boards. The idea is to drive multi-agent work from project-board state so issues and tasks become the queue agents pull from. Early-stage with sparse documentation.

Cruxton: Decision Records So Agents Stop Re-Proposing Rejected Ideas

A decision-records system that captures why a choice was made and which alternatives were rejected — the human reasoning an agent cannot re-derive from the code. Agents consult the records instead of re-researching paths the team already ruled out weeks ago. Targets the common annoyance of Claude Code confidently suggesting an approach you already killed.

What to Put in /compact's Optional Summarisation Instructions

Thread on steering Claude Code's /compact with explicit summarisation instructions instead of letting it compress blindly. The author ran a six-hour orchestrator session and describes the tradeoff they hit: compacting without guidance degrades the agent, while never compacting burns usage at an accelerating rate. Useful if you run long orchestrator sessions that outlive one context window.

Hiding Secrets From Claude Code at the Filesystem Level With Devcontainers

Instead of relying on deny rules, this setup runs Claude Code inside a Docker devcontainer where secrets are simply not mounted, so the agent cannot read what isn't there. Quick start is 'Reopen in Container' with no manual mount config. Includes a worthwhile finding: Claude Code's built-in deny rules don't traverse parent directories, which leaves gaps in monorepos.

Claude Code Web Sessions Starting on Stale Commits — the Environment Cache

Report and diagnosis of Claude Code web sessions resuming a long-lived feature branch at a commit nine steps behind GitHub, traced to the cached environment rather than the branch picker. The agent then reads outdated project notes and works from the wrong state. Worth reading if you keep one branch per milestone on Claude Code web instead of merging to main each session.

TS Evidence Graph: Turning Specifications Into Compile-Time Obligations

A TypeScript pattern where @evidence annotations link every implementation back to the doc section, endpoint, hook, or principle it satisfies, and citing the reason is mandatory. The compiler then enforces that each requirement is covered, giving a mechanical check on requirements coverage and principle compliance rather than a review-time promise.

claude-harness: Japanese-First Claude Code Starter Kit for Real Work

Hands-on OSS starter kit covering skills, subagents, hooks, MCP, plugins, and a four-window worktree layout, written Japanese-first for the 2026 feature set. Aimed at people moving past demos into daily production use of the agentic CLI.

discussion-to-superpowers: The Design Layer obra/superpowers Assumes

Turns a design conversation into durable project documents, an ordered roadmap, and one session-ready run sheet per feature — the upstream artifacts superpowers expects to already exist. Bridges the gap between an unstructured idea discussion and a workflow that can actually be executed feature by feature.

capstan: Gated Concept-to-Delivery Pipeline for Claude Code

Claude Code plugin that moves work through explicit gates with specialized roles, test-first slices, review, and verification before anything is called done. Structures a feature as a sequence of checkpoints instead of one long agent run.

tldr-experts: A File-Based Five-Phase AI Development Loop

Lightweight workflow where expert definitions live as files on disk and work moves through one loop of five phases. Pre-alpha. Deliberately avoids a runtime or service — the whole method is plain files in the repo.

perf-audit: Specialist Agents That Hunt Memory Leaks, Jank and N+1

Claude Code plugin with a team of specialist agents auditing backend, frontend, and mobile code for memory leaks, CPU and thermal overuse, jank, OOM, N+1 queries, and DoS exposure, including live-profiling arms. Broader than the usual single-pass performance linter.

stuntman: Plan With Claude, Execute With a Cheap Model, Review With Claude

Delegation harness that keeps Claude on planning and review while a near-free model does the bulk execution, on the theory that Claude shouldn't do its own stunts. A concrete implementation of the cost-tiering pattern people usually run by hand.

claude-best-practice: Patterns From Vibe Coding to Autonomous Agent Teams

Long-form guide organising Claude Code practice as a progression — ad-hoc prompting, then agentic engineering, then autonomous development teams — with the patterns each stage needs. Useful as a map of the territory if you're deciding what to adopt next.

Coordinating Claude Code, Codex and Cursor Through the Filesystem

Multi-agent collaboration on a single machine where Claude Code, Codex, and Cursor coordinate through filesystem protocols rather than a server. No infrastructure beyond agreed-on files and directories.

dev-bootstrap: Portable Neovim + Claude Code Environment With tmux Panes

Reproducible setup pairing Neovim and Claude Code in an nvim|claude tmux layout, with /new-project scaffolding, /parallel-tasks that open as tmux windows, and a lint/test feedback loop. Parallel work becomes windows you can watch rather than background jobs.

software-factory-rs: Pull-Based Agents in a Sandboxed Rig With a Beads Ledger

Give it a plan and it returns a verified, merged codebase. Agents (Claude Code, OpenCode, Codex) pull work from a Beads ledger inside a sandboxed rig, with typed railway-oriented Rust and a done-means-verified rule. Pull-based dispatch avoids the coordinator bottleneck most orchestrators hit.

helioz: Continuity Orchestrator With Watchdogs and Adversarial Probes

Orchestrator for agent teams that keeps state on disk and enforces task gates, independent verification, budgets, watchdogs, and adversarial probes. Built around the assumption that a long agent run will stall or drift and needs external checks.

zeuz: Reference Factory for Role-Based Agent Workflows

Reference implementation of a role-based agent workflow covering requirements discovery, architecture gates, observability, tests, and human approval points. Meant as a pattern to copy rather than a product to adopt wholesale.

chock-claude-plugins: Policies as Installable Plugins, With Enforcement Stated

Chock policies packaged as Claude-format plugins generated from a shared catalog, where each plugin declares whether it actually enforces in your client or is only advisory. That honesty about enforcement is unusual and worth borrowing.

samewrite: Where Coding-Agent Sessions Actually Spend Tokens, Measured

Analysis of 1,316 Claude Code transcripts and 342 scored A/B runs. Findings: cost is carry, so Bash and Read account for 63.8% of it; the 'emit only the changed block' rule is net negative; 72.9% of skill-listing bytes belong to skills never invoked; terseness cuts output 23.4% but no skill beat a one-sentence version of itself. Directly contradicts several popular optimisation habits.

agent-orchestrator-kit: Orchestration Scaffolding for Three Agent CLIs

Portable orchestration kit that sets up the same multi-agent structure across Cursor, Claude Code, and Amp Code, so the workflow doesn't have to be rebuilt per tool.

repo-agent-harness: Make the Repository Teach Agents How to Work in It

Lays down hooks, layered documentation, guards, gates proven to actually fail when they should, and a repo graph — then stays out of the way. The 'proven to turn red' requirement is what separates it from guard configs nobody has ever seen trigger.

meute: spend leftover subscription quota on scheduled unattended repo work

A scheduler that puts idle Claude Code or Codex subscription quota to work by running unattended jobs across your local repositories on a timetable, with a separate capped track for open-source contributions. It runs without a daemon or database, so setup is just configuration plus cron-style scheduling. Useful if you pay for a plan monthly and routinely leave capacity unused.

polako: Unattended Issue-to-Merged-PR Runner With Human Gates

Works a GitHub issue backlog down to zero, one issue at a time, without supervision between steps. Each stage from issue triage to merged PR has an explicit human approval gate, so the agent runs long but never merges on its own. Aimed at grinding through accumulated small issues.

Measured Across 34,215 API Calls: 360 Tokens Re-Read Per Token Written

A developer instrumented 637 of their own sessions and found cache reads were 98.5% of billed tokens, cache writes 1.2%, and model output 0.3%. The median session sits at 97.6% re-read with p10 at 91.2%, so it holds across the distribution rather than coming from outliers. Worth reading with the caveat the author raises: cache reads are billed at a fraction of input tokens, so these are token shares, not dollar shares.

spec-lane: Local-First Delivery Workflow With Acceptance Gates

Runs AI-assisted changes through premise checks, spec consensus, and acceptance gates before anything ships, with cost calibration at each stage. Emits agent metrics so you can see where the workflow actually spends effort. Everything runs locally rather than through a hosted service.

Treating Claude Code as a Design Environment With Per-Domain Skill Files

A frontend workflow that swaps ad-hoc prompting for a workspace of purpose-built .md skills (shadcn, GSAP, taste, frontend design) that Claude Code loads depending on what is being built. The process starts by handing Claude an asset folder so it knows what images and references exist, then works through UI/UX requirements using the relevant skills. Useful as a concrete example of skill-file decomposition for design-heavy projects.

opc-agents: A Director Plus Nine Specialist Agents for Solo Operators

A "one person company" agent team where a Director agent coordinates nine specialist roles across a project. Runs on either Claude Code or OpenCode, so the same team definition is portable between harnesses. Useful if you want a ready-made role split rather than designing subagent responsibilities from scratch.

scavengers-assemble: Multi-Model Coding Harness Across Claude, Gemini, GPT and Ollama

An Avengers-themed orchestration harness where a lead agent delegates coding work to Claude, Gemini, GPT-4, Grok and local Ollama models. It drives the vendors' existing CLIs so it runs on subscriptions you already pay for rather than metered API keys. Open source, aimed at people who want to mix models on one codebase.

hivemind: Claude Code Plans and Reviews While Free OpenCode Workers Do the Work

A cost-splitting swarm pattern: Claude Code handles planning and review, then hands implementation to parallel OpenCode workers, each isolated in its own git worktree. Workers communicate back through a deliberately minimal one-JSON-line contract, which keeps the coordinator's context small. Worth a look if you want parallelism without paying premium rates for every edit.

claude-project-flow: Six Approval-Gated Phases From Idea to Shipped Code

A Claude Code plugin that structures a project as six sequential phases, each requiring your explicit approval before the agent moves on. The gates are the point — they stop the agent from racing from a rough idea straight to a large diff. Suits people who want a repeatable process rather than freeform prompting.

tenet: A Commitment Ledger That Keeps Project Decisions and Rules From Rotting

Records the decisions and rules a project has committed to, and ships the machinery to keep those records honest as the codebase moves underneath them. The problem it targets is familiar to anyone with a long CLAUDE.md: rules accumulate, silently go stale, and the agent keeps following them. Documentation is sparse, so expect to read the repo.

Bench: A Constitutional Governance Layer for Claude Code

Puts a governing document between you and the agent, so behaviour is constrained by explicit written principles rather than instructions scattered across prompts. Positioned as a governance layer rather than another rules file. The README is terse — read the repo before adopting it.

super-backlog: Add Task Tracking, Skills and a Dashboard to Any Repo in One Command

A single installer that drops a complete agent workflow into an existing repository: Backlog.md task tracking, the Superpowers skill collection, and a live project dashboard. It installs in seconds and, notably, uninstalls cleanly — so trying it does not leave residue in the repo. Good for evaluating a structured agent workflow without committing to it.

claude-code-toolkit: One-Command Project Bootstrap for .NET, Java, Python and Rust

Bootstraps a repository with a production-shaped Claude Code setup in a single command, using per-stack templates for .NET, Java, Python, Rust+Tauri and MAUI, with a generic fallback for anything else. Aimed at the setup tax you pay on every new project. Note there are several unrelated projects sharing this name.

sota-numerics: Force an Alternatives-Considered Section Into Every Plan

A Claude Code plugin that layers research and numerical-stability advice onto the GSD plan/execute/verify/ship lifecycle, and adds a blocking gate that refuses to let a plan proceed without an explicit Alternatives Considered section. The gate is the interesting part — a mechanical check against the agent locking onto its first idea. Most relevant to numerically sensitive work.

Dely: Chain Claude Code, Codex and Grok Build Into One Review Loop

A plugin that sequences several official coding harnesses — Claude Code implements, another harness reviews, then accept or replan — without copy-pasting prompts between terminals. Built by a dev who prefers separate harnesses over sub-agents. Supports Codex, Grok Build, Antigravity and Kiro alongside Claude Code.

fun-with-friends: Stand Up a Multi-Agent Claude Code Dev Factory on Any Repo

Point it at a git repo and it builds an ideas-to-ship pipeline you drive by talking to a "captain" agent. Ships refactoring, ideation and dev-SRE factory templates, per-role model config, an eval harness, and a no-push local-issues mode for repos you do not control.

kernel-claude: Prove Which Claude Code Rules Actually Work

Combines persistent memory and multi-agent orchestration with an experiment engine that A/B-tests your rules to see which ones measurably change behavior. Aimed at people whose CLAUDE.md has grown past the point where they can tell what still helps.

jen-marketplace: PMO-Style Orchestrator With 18 Building and Verifying Agents

A Claude Code marketplace where a Fable 5 conductor coordinates 18 agents that build and verify work against a stated goal. Modeled on a project management office rather than a flat swarm.

autoagent: Harnesses That Tune Their Own Prompts, Tools and Config

A framework for building autonomous agent harnesses that iterate on their own prompts, tool sets, configuration and orchestration while benchmarking each change. For people treating harness design itself as an optimization problem.

Loop-Dee-Loup: A Token-Lean Execution Loop for Autonomous Agents

An opinionated execution loop designed to keep autonomous coding agents cheap — minimal context reloading and tight iteration boundaries. Useful if long autonomous runs are burning tokens on re-reading state.

godmode: 126 Skills and 7 Subagents With Rollback and Failure Memory

A large autonomous coding plugin spanning five harnesses — Claude Code, Cursor, Codex, Gemini CLI and OpenCode. Iterative optimization with automatic rollback, a memory of past failures, and parallel multi-agent execution.

Atlas (Ctrl1CandV): Local Auditable Multi-Model Workflow Engine

Define a workflow as a YAML graph, control it through six MCP tools, and inspect the complete input and output of every node in a local web UI. Everything runs on your machine, so multi-model pipelines stay auditable.

Orient: A Living Map of State, Decisions and Why for Coding Agents

Maintains a running map of what you are building — current state, decisions taken and the reasoning behind them — readable by Claude Code, opencode and Codex. Explicitly designed to stay cheap enough that it never becomes friction.

Are Better Models Replacing Superpowers? A Token-Cost Comparison

A developer compared the Superpowers subagent framework against a plain Opus 5 run and a simple Opus-builder/Fable-reviewer pair, building the same gym booking app. All three succeeded, but Superpowers cost more than double the tokens. Argues that with a strong spec, the full subagent delivery process may no longer pay for itself.

QuietHarness: A Lightweight Work System Shared by Claude Code, Codex and Cursor

A minimal AI working system meant to be shared across Claude Code, Codex and Cursor rather than reimplemented per tool. Chinese-language docs.

Opus 5 Review Strategy: Three Layers to Stop Scope Creep

A one-line fix turning into eleven changed files is a documented Opus 5 behavior. This writeup proposes enforcing scope in three escalating layers, cheapest first: name the allowed paths in the prompt, and remove "verify your work" lines from CLAUDE.md since the model already over-verifies.

Claude Code Can Read the Repo and Still Lose the Task

Argues the bad session reset is not always a context-window problem: the next session has the repo but not the history of what was tried and rejected, what is still failing, and what not to touch. A bigger context window gives more text, not a reliable record — CLAUDE.md holds rules, git holds changes, and something else has to hold decisions.

awesome-ai-agent-governance: Policy, Audit and MCP Security in Production

A curated list of tools, standards and resources for governing AI agents in production — policy enforcement, audit trails, EU AI Act compliance, and MCP and Claude Code security. Useful if you are being asked to justify agent deployments to a compliance function.

agent-relay: Durable Handoffs and Sealed Versions Across Coding Agents

Install once and get durable project handoffs, instant status readouts, sealed versions and coordination between multiple AI coding agents. Aimed at the state loss that happens when work moves between sessions or tools.

spec-driven-guide: Five Phases Enforced Across Six Different Agents

A CLI that installs AGENTS.md plus on-demand skills so Claude Code, Cursor, Copilot, Codex, Gemini and Windsurf all follow the same five phases: spec, plan, code, test, end. Governance without picking a single tool.

ai-codeops-harness: A Tool-Agnostic Engineering Harness for Coding Agents

An engineering governance framework that deliberately avoids binding to one AI coding tool, so the process survives switching harnesses. Chinese and English docs.

agentic-covenants: Agent Governance Mapped to NIST CSF 2.0

A practitioner framework for autonomous-agent governance built as six matrices mapped to NIST CSF 2.0, with working Kyverno policies, Falco rules and kill-switch runbooks in every populated cell. Concrete artifacts rather than a policy document.

Ask Claude to Audit Its Own Transcripts for Whether It Uses Your Skills

A simple check for whether your installed skills are actually firing: ask Claude to read its past session transcripts and report how often a given skill was invoked and which operations were used. Full file reads and direct CLI shell calls are evidence the skill was bypassed.

breakthrough-harness: A Discipline Layer to Make Research Agents Hard to Fool

Adds structure to agentic research: a breakthrough loop, an un-foolable harness checklist, claim-polarity gates, and engineering rules recorded with the cost of learning them. Aimed at agents that confidently confirm whatever they set out to prove.

Claude Code Kept Recreating UI Components I Already Had

A developer describes the recurring failure where Claude Code writes correct-looking JSX that quietly duplicates existing components, variants and tokens from the project design system. The hard part is not generating markup but getting the agent to understand the component system already present and decide what to reuse.

Opus 5 vs 4.7 vs 4.6 on the Same Skeptical Code Review

A side-by-side comparison of the three models reviewing the same set of ~145 tooling commits. Opus 5 scanned all 145 directly and returned 7 findings plus an opinion; 4.6 scanned ~60 with three forks and returned 15 findings; 4.7 returned 9. Time to first report ranged from 4m41s to 10m56s.

One Dev Plus an Agent Fleet: An Interactive Map of a Full Agentic SDLC

A solo engineer running a production SaaS mapped their entire delivery process into one interactive artifact — backlog, refinement, design, implementation, verification, a human merge gate, deployment and monitoring, with a central workshop for the standing setup. Posted explicitly asking to be critiqued.

rein-agentic-kit: Bounded Loops and Per-Agent Model Routing

Keeps Claude Code agents lean with bounded agent loops, per-agent model routing and real per-model token measurement, so you can see which agent in a fleet is actually consuming the budget.

ownframework-loop: Human-Gated Work Packets With Exact-SHA Verification

A Claude Code engineering workflow where a human approves each work packet, build and review cycles are bounded, changes are verified against exact commit SHAs, and promotion stays manual. For teams that want agent throughput without automatic merges.

pilotfish: Frontier Model Plans, Cheaper Models Execute

A multi-model orchestration layer for Claude Code where the frontier model does the planning, cheaper models carry out the steps, and a verification pass guards quality. Installs from a single prompt. The pattern targets cost reduction on long task chains without giving up plan quality.

nautilus-compass: Keep Multi-Agent Setups Coordinated Without an Orchestrator

A reliability layer for multi-agent workflows that replaces a central orchestrator with cross-dialog contracts between agents. Adds drift detection and a black-box memory store that does not rely on LLM extraction. Useful if you run several agents on the same problem and they keep diverging from the agreed plan.

personal-brand-site-starter: Four-Phase Agent Flow for Building a One-Page Brand Site

A zero-dependency starter that walks an AI agent through four stages — interview, style selection, build, and acceptance check — to turn someone's own words into a single-page personal brand site. Ships four visual styles with animated hero sections. Documentation is in Traditional Chinese.

Fixing Claude Code Cross-Session Inconsistency With ADRs Instead of a Longer CLAUDE.md

A solo developer describes how growing CLAUDE.md failed to stop Claude re-litigating settled decisions each session, and how 20+ architecture decision records fixed it instead. Written from a real project (self-hosted WireGuard access management, Quarkus + Vue, 700+ tests). The takeaway: record the "why" as ADRs and point the agent at them rather than piling up rules.

toolbox-ai-assisted-secure-code-review: Materials for Running a Secure Code Review With an Agent

A curated toolbox of prompts, checklists, and supporting materials for driving a security-focused code review with a coding assistant. Structures the review rather than relying on a single "find vulnerabilities" prompt.

Splitting Claude Code by Model: Sonnet for Edits, Opus for Design and Review

A workflow that assigns filesystem-heavy execution (edits, tests, iteration) to Sonnet while reserving Opus for architecture, hard debugging, and independent review. The hard part is giving the reviewing model enough repo context without a full rediscovery pass, which the author solves with a local context-preparation tool.

arbiter (LucaDominici): Generate AGENTS.md, Tool Configs, and Quality Gates for Any Repo

A governance framework that scaffolds AI development setup for a repository: AGENTS.md, per-tool configuration, GitHub infrastructure, and quality gates. Aimed at standardizing how agents are allowed to work across many projects.

weaver (sean35mm): Shared Situational Awareness for Agents in the Same Repo

Gives multiple coding agents working the same repository a common view of what each is doing. Targets the conflicts and duplicated work that show up once more than one agent edits a codebase concurrently.

Using Apple Intelligence to Summarize Claude Code Chats Overnight for Free

The author found roughly a third of their weekly token usage went to re-reads — unchanged files read again, old chats pulled into new ones. Their fix runs a local Apple Intelligence pass over each finished session to write a handoff (what happened, what was decided, what is next, which files were touched), so the next session starts from a summary instead of the raw log.

plumbline (dr-zog): Enforced Traceability From Requirements to Code

A zero-dependency Go engine plus a Claude Code plugin of skills that keeps a light but enforced link between requirements and the code implementing them. Aims for traceability without the ceremony of a full requirements management tool.

code-quorum: Independent External Seats for Plans, Reviews, and Validation

A multi-agent council spanning Claude Code and Codex where each seat is an independent external reviewer for planning, code review, brainstorming, validation, or research. Structured so opinions are formed separately before being reconciled.

vibeArchitecture 1.5.0: Agentic AI Security Guardrails Mapped to OWASP

A free MIT guardrails repo whose 1.5.0 release adds a guide mapped to the OWASP Top 10 for Agentic Applications: delegated credentials instead of one god key, memory poisoning, tool-description poisoning, and spend caps with a kill switch — including what to do when your agent reads a web page that tells it to do something else. Also refreshed against OWASP Top 10 2025, LLM Top 10 2026, the July MCP auth spec, NIST 800-63B-4, and WCAG 2.2.

davinci (Deadshot-77): An Autonomous Dev Team With Hook-Enforced Review Gates

Models a development team in Claude Code: a clarifying intake agent that pins down the request, an orchestrating tech lead, scoped builder agents, and review gates enforced by hooks rather than convention. The hook enforcement is what stops the pipeline skipping review when the agent is in a hurry.

same-session-model-switching: Swapping Model Backends Inside One Long Session

A reference architecture with a tested control-plane example for changing which model backend serves a long-running agent session without restarting it. Relevant to cost and capability routing mid-task.

Teknesyum Base: Sizing, Splitting and Auditing Work Automatically

A multi-agent relay for Claude Code that takes a plain request, sizes the job, splits it into pieces, assigns agents, then runs an independent auditor over the result. Ships with a neon UI standard so generated interfaces stay visually consistent.

loopspec: Compile a Vague Task Into a Harness-Gated Spec

Takes an informal task description and compiles it into a delegation spec where a test harness — not the model's own judgement — decides when the work is done. Addresses the common failure where an agent declares success on an under-specified task.

oh-my-harness (IISweetHeartII): Maintained Fork With CI-Proved Gates

A maintained derivative of revfactory/harness that ships the upstream project's unmerged v2 rebuild along with reviewed community pull requests. Its CI proves its own quality gates, so the agent-team and skill-factory features are verified rather than asserted.

Why Resuming an Old Session Burns Your Usage Limit

Explains that Claude Code enables prompt caching by default and that cache writes are the expensive part — so resuming a session idle for over an hour re-writes the whole cache. The habit of returning to a stale session 'because it has all the good context' is the single biggest avoidable cause of limit burn.

A Pacing Chart for the Weekly Limit: 51% by Wednesday Night

Works out what percentage of the weekly usage limit you should have spent on any given day — 17% per weekday if you work weekends, 20% if you don't, anchored on being at 51% Wednesday night. The author notes the limit isn't linear in practice, so treat it as a budget rather than a prediction.

secondmate: A Rival Model Tries to Break What Yours Wrote

Your agent writes the code, a different model attacks it, and only what survives the cross-model review reaches a gated merge with a human approving. Uses model diversity as the review signal rather than asking the same model to check its own work.

research-ratchet: Claims Advance Only Through Gates

A methodology for AI-assisted research where each role is defined by what information it is allowed to see, and a claim only moves forward by passing an explicit gate. The information-diet framing is a deliberate defence against agents laundering assumptions into conclusions.

The Bugs Were in the Markdown: Auditing 150 Files of Agent Docs

After months of blaming the model for inconsistent answers and ignored rules, the author audited their agent setup and found 50+ instructions pointing at files that no longer exist and roughly 70% of the docs dead. A useful reminder that a growing CLAUDE.md and skill tree needs pruning, and that broken pointers degrade behaviour silently.

solidforge: Converge, Specify, Implement With Gates That Can't Go Silently Green

A Claude Code plugin implementing a loop-engineering pipeline — converge on the problem, write the spec, then run parallel TDD implementation behind dual-ring convergence gates. Adds adversarial cross-source review, source-grounded citation checks and prior-art collision search, with honest coverage reported at every gate.

Do Fork Subagents Really Resend the Whole Conversation?

A session split across four parallel fork subagents burned about 2M tokens for modest work, prompting the question of whether a fork inherits the entire parent conversation and re-sends it on every tool call. Worth reading before fanning out forks from a context-heavy session — the cost model is not obvious from the UI.

Building Verifiable MBA Case Studies With Verification-Debt Tracking

A GitHub template for producing business school case studies with agentic AI, using source tiering and explicit verification-debt tracking so unchecked claims stay visible. The verification-debt idea generalizes well beyond case studies.

ai-pack: Six Subagents and a Knowledge Graph as an Engineering Team

A Claude Code plugin that turns a session into a small engineering team — six specialized subagents plus orchestration and PR-shepherding skills, backed by persistent knowledge-graph memory that survives between sessions.

model-loop: Let a Rival CLI Attack Your Plan Before Any Code

The invoking agent writes the plan, then a different CLI — agy, Cursor, Codex or Claude Code — attacks it before implementation starts. Cross-harness review at the planning stage, where fixing a flaw is cheapest.

many-hats: A Cloneable AI Product Team Across Five Agents

A clonable product-team setup — roles, handoffs and responsibilities — that works in Cursor, Claude Code, Codex, Copilot and Windsurf. The human stays the decision maker rather than being routed around.

Synapse: A Bug Bounty Pipeline That Kills Its Own Findings First

A multi-agent bug bounty research pipeline built on Claude Code agents, hooks and schema-checked artifacts, where findings are adversarially validated and discarded before they ever reach you. Directly targets the noise problem that makes agent-driven security research unusable.

Measuring How Much Context an Agent Must Read: Plain vs Framework Stacks

A developer measured the text a coding agent must read before safely changing one code path, comparing C vs C++, Java+JDBC vs Spring+JPA, and vanilla JS vs React. Hand-written code size was similar, but framework stacks pulled in 59k-132k tokens of external convention and source versus 7.6k in-repo for the plain path. A concrete data point for how stack choice affects agent context budgets.

Five-Vendor Code Review Panel via Any OpenAI-Compatible Endpoint

A Claude Code plugin that gets code review from non-Claude models by talking plain HTTPS to any OpenAI-compatible endpoint, instead of shelling out to Codex or Gemini CLIs. Because NVIDIA build.nvidia.com hosts DeepSeek, Kimi, Nemotron, and MiniMax on a free tier, you can seat a five-model panel on one key. The authors key finding: giving each panelist a distinct role (correctness, architecture, security, regression, performance) surfaced far more distinct defects than five identical review prompts.

Four Agents for Managing Claude Like an Employee: Radar and Friends

A CTO frustrated with Opus wrote four agents and commands to manage it like a report rather than argue with it. Radar triages new issues and bugs at session start, reports repo state and logical next steps, and flags which work can run unattended versus which needs human time. Runs on Sonnet with tight guardrails, and the framing itself is the useful part: treat agent quirks as management overhead, not defects.

Combining Spec-Driven Development, Project Memory and Hooks

A platform engineer's writeup of an agentic development workflow that pairs spec-driven development with persistent project memory and Claude Code hooks. The aim is to give the agent enough engineering intent per session without replaying the whole project history into context every time. Comes with an accompanying repo (claude-spec-mem) implementing the setup.

specflo: A Python CLI Driving Brainstorm, Spec, Plan, Execute Loops

Spec-driven software engineering for coding agents, implemented as a Python CLI that walks a project through brainstorm, spec, plan, and execute stages. Every artifact lands as markdown on disk, so the intermediate reasoning is reviewable and version-controllable rather than trapped in a chat log. Fits teams that want the agent's plan under code review before implementation starts.

review-switch: Dispatch Code Reviews to Pluggable Reviewer Lanes

Lets you route a code review from inside Claude Code to whichever reviewer backend you want — a Claude plugin lane or a Codex TUI lane — through one dispatch point. Swapping reviewers becomes a config choice instead of a different manual process per tool. Handy if you deliberately want a second model's eyes on a diff.

gauntlet: Provider-Neutral Review Harness With Four Checkpoints

A review-only code review harness that runs one engine at four checkpoints in the development cycle, sharing verdict memory between them so earlier findings carry forward. Provider-neutral, so it is not tied to a single model vendor. Aimed at teams who want consistent review gates rather than ad-hoc prompting.

claude-starter-kit: Enterprise Workflow With Security and Approval Gates

An engineering workflow for Claude Code built around agents that plan, build, audit and ship, with security gates, privacy checks and approval-controlled commits between stages. Designed to be adopted into existing repositories, not just greenfield ones. Aimed at teams that need review discipline around agent-written code.

tollens: Agent Results Stay Candidates Until Executable Evidence Passes

Applies modus tollens to agent output: a result is only a candidate until executable evidence, bound to the exact evaluated snapshot, survives an external gate. Uses mutation-style reasoning, where a surviving mutant disproves the claimed guarantee. The framing is abstract, but the underlying idea of refusing to accept unverified agent claims is sound.

ai-native-sdlc: Plan-to-Deploy SDLC Plugin With Human Approval Gates

A reusable skill and plugin implementing Anthropic's AI-Native SDLC as an explicit pipeline: Plan, Design, Build, Test, Deploy, Maintain. Each handoff between stages requires human approval, so the agent cannot silently skip from design straight to shipping. Works with both Claude Code and Codex.

ilk-skills: Staged Execution Loop That Drives a Verifiable Plan to Done

Decomposes a task into a plan with verifiable stages, then runs a loop that drives each stage to completion instead of relying on the agent to remember the whole job. The loop is agent-agnostic, working across Claude Code, Cursor, and Codex. A structured answer to long tasks that drift halfway through.

The Until Loop: Gate Claude Code's Output Against a Plan You Agreed First

A workflow for the gap between green CI and actually-built: agree a written Plan before any code exists, then keep building until the code matches it, with a hook enforcing the check. The premise is that tests and agent summaries both pass while requirements quietly go unimplemented, and line-by-line review does not scale. Posted by someone who works on the commercial tool shown, but the loop pattern itself is reusable.

gauntlet-loop: Builder-Critic Validation Loop With Cost Limits and Stop Rules

A method for validating LLM output against criteria defined up front, run as a builder-critic loop with explicit evidence checks. It includes cost limits and stopping conditions, so the loop terminates instead of grinding indefinitely. Useful if your review loops currently have no defined exit.

An Adversarial Review Gate on a Different Model Caught Five Real Defects

Every money-touching change in this project passes an adversarial review gate before deploy: a second, independent model reads the diff looking for a reason to reject it. The reviewers were deliberately Gemini and GPT-OSS via Antigravity rather than more Claude subagents, so the reviewer is not the model that wrote the code. Three passes found five real defects, including a failing payment that could roll back and release a lock.

Running Coding Agents in Lanes Instead of One Chat Doing Everything

A pipeline where a lead agent files a GitHub issue and separate runs handle implementation, QA, review, CI, and telemetry — no session implements, reviews, and merges. Each lane writes started/done/blocked/failed to SQLite plus a GitHub comment, and the next lane reads that state before acting. Works the same across Claude, Codex, and Grok.

Why "Unusually Disciplined" in a Repo Review Is a Warning Sign

A field note on letting agents build hundreds of tests and pins that look rigorous but that you stop understanding halfway through the project. The praise from a review agent reads as validation right up until the suite becomes the thing blocking every change. Useful counterweight if your agent-built test suite keeps growing.

disensor: Enforced Residue Declarations at the End of Each Review Round

Claude Code writes the plan or code, a reviewer from a different model family attacks it, and the round only closes when every finding is fixed, refuted with evidence, or escalated. disensor makes Claude emit a JSON artifact recording each finding's terminal state and what the cycle could not resolve, and a GitHub Action blocks merge without a valid declaration covering the tree.

Opus 4.8 vs Opus 5 Compared on 25 Tasks From One Real Repository

The author ran both models once per task on 25 tasks drawn from merged work in their own repo, medium reasoning, identical criteria. The strict test-pass score tied at 9/25 each, sharing 8 tasks. Opus 5 searched wider and verified more — more shell commands on 18 of 25 tasks and more revision passes — while 4.8 stayed more contained.

An Adversarial PR Review Workflow Where Two Models Fight and a Judge Consolidates

A principal engineer running a dozen active repos wired up a persistent Claude Code session that takes a PR link and launches two models to attack the diff from opposing angles, with a judge consolidating. Only findings that survive get posted as review comments, which keeps the noise off the team.

Two Weeks of a Multi-Agent Claude Code Team: 253 PRs Merged

Agents split into implementation, testing, review, QA, and remediation roles, with work moving through GitHub issues to PR to independent review to merge — 253 PRs, 4,410 tests, roughly 67,000 lines over two weeks. The write-up focuses on what broke, notably "plausible code" that reads correct and passes review without being right.

senmu-buildos: Full-Lifecycle Project Governance Plugin for Coding Agents

An open-source plugin covering requirements, workflows, engineering, delivery, assurance, and organizational learning for Codex, Claude Code, and other agents. Chinese-language documentation. For teams that want process structure around agent work rather than ad-hoc prompting.

outsource: Drive the Grok CLI as a Headless Sub-Agent From Claude Code

Field-tested invocation recipes for running grok CLI as an implementation sub-agent under Claude Code, with git-safety profiles to bound what it can touch. Ships blind-judged evidence showing test depth going from 14 to 81.

janus: A Claude Code Starter Template That Learns From Its Own Sessions

A project template that extracts lessons from its own Claude Code sessions and passes them down to the projects it spawns. The interesting mechanic is inheritance — new projects start with accumulated knowledge instead of a blank CLAUDE.md.

ark-space: A Workspace for Orchestrating Agent Skills, Roles, and Workflows

A creative workspace that coordinates skills, roles, and workflows across Claude Code and other agents, aimed at composing them rather than invoking each by hand.

foundry: Spec-Driven Development Suite for Greenfield and Brownfield Work

Covers three modes explicitly — zero-to-one greenfield, taking over an existing brownfield codebase, and continuous feature delivery. Brownfield takeover is the one most spec-driven tools skip.

agentic-harness-notes: One File Per Problem From Running Claude Code and Codex

A running log of problems hit while operating agentic coding harnesses, with the fix for each, kept one problem per file so entries stay searchable and citable. The format is as reusable as the content.

goal-workflow: /prd, /goal, /review-it, and /ship-it Skills

A development workflow expressed as four slash commands running from product requirements through goal setting, review, and shipping. Small surface area compared to most spec-driven suites.

proof-loop: A Repo-Local Verification Protocol for Coding Agents

Defines acceptance criteria up front, assigns verification to a separate role than the one implementing, and requires proof artifacts before an agent can claim done. Lives in the repo, so the protocol travels with the code.

spec-driven-agent-orchestrator: A Gated Spec Pipeline for .NET Agent Harnesses

A gated spec pipeline for coding agents with a .NET-focused harness guide. Useful mainly if you work in the .NET ecosystem, where agent tooling is thinner.

verified-ops-starter: Prove Your Scheduled Job Actually Did the Work

Exit 0 is not evidence. Three stdlib-only checks — output freshness, silent no-op detection, and rollout proof by reading the fact back — sanitized from a live agent fleet. Free and MIT.

verdict-contract: A Parseable Contract for LLM Reviewer Verdicts

When an LLM reviewer says APPROVE, this makes that machine-checkable: a prompt rule, a parser, and an exit-code gate in one stdlib file, documented alongside the 42 counterexamples that shaped it. Free and MIT.

oss-publish: Open Up Internal Work Without Leaking It