Agent Compounds

Agentic tools that compound. Each builds on the last.

The canonical home for portable skills and agents. Deploy any subset into a project's .claude/ with deploy.sh — everything is symlinked back here, so this repo stays the single source of truth and edits propagate instantly.

Skills

Symlinked into a project as .claude/skills/<name>/.

Multi-model

Skill	What it does
openrouter	Access 400+ AI models. Discover, select, and query the right model for any task
expert-consensus	Fan out one prompt to multiple AI models, synthesize into consensus

Pipeline — the engineering workflow, one skill per stage, all ac- prefixed. The runtime conductor is ac-implement; the design lives in ac-pipeline. Three operational loops feed one execution path (see ac-pipeline § The three operational loops): the dev loop (human intent → plans → waves → ac-implement ships), the triage loop (ac-triage, scheduled — production signal → defect beads), and the audit loop (audit + ac-hygiene, periodic — proactive hardening findings → beads).

Skill	What it does
ac-pipeline	The pipeline doctrine — canonical stage order, each stage's contract, cross-cutting invariants, the three-loop model
ac-beadify	Compile an approved plan into lean beads — the four-section schema (Intent / Acceptance Criteria / Delivers / Consumes), a Consumes↔edge-wired dependency graph, plan retirement; refuses any bead whose ACs name no executable probe (no probe, no bead)
ac-polish	One fixpoint engine, four modes (plan · bead · code · seams) — a stateless severity-gated reader per round, sent references/reader-prompt.md verbatim, reporting edits + a mandatory DECLINED list; stamped by skills/_tools/polish-fixpoint.sh only against a measured empty diff at round ≥ 2; runs until it converges. seams (a.k.a. ac-seams) resolves an area to its heaviest object and TRACES it through three lenses per round — object (lifecycle stages), flow (steps with controller/sensor/on-failure), boundary (both sides' assumes/asserts) — converging on the merged maps (scripts/seams-merge.py, exact keys per lens) and deriving the seams (holes, competing writers, unasserted edges, unsensed steps, unchecked assumptions; cross-lens first) plus the ac-qa journey into a plan for ac-plan; scripts/aim.sh churn ranks FILES from git churn + no-import co-change, aim.sh objects [--area] ranks data OBJECTS by seam load (touchers × layers × writers ÷ tests) — the bridge from an area or a hot file to the object a trace needs
ac-plan	Idea → ONE plan file — problem, approach, artifact-named deliverables, assumptions with detection rules, risk + sequence, out-of-scope, and a success criterion the skill refuses unless it can come out false
ac-implement	Work an epic's bead queue as a SWARM (default width 3, uncapped, until the qualifying beads are exhausted) — the invoking session coordinates, spawned workers run references/worker.md: flight-check.sh at claim, RED first, swarm-commit.sh at commit, close-gate.sh at close; coordinator.sh owns the close-out (stale-ledger refusal, orphan sweep, one ledger commit)
ac-publish	The ship gate — ac-prove obtains the proof and this gate asserts its REQUIRED JOBS ACTUALLY EXECUTED, refusing NOT-GATED on a job that was absent, skipped or cancelled; then version once, tag the proven SHA (never HEAD), promote-not-rebuild on web, CI-built artifacts only on native, hand off to ac-distribute
ac-backlog	Capture ideas into grouped backlog files (front of the pipeline)
ac-triage	Pull operational + user signal back in (crashes, errors, beta feedback), cluster it, route real findings by shape
ac-align	Reconcile the pipeline with current strategy
ac-plan-lab	Deep analysis of a plan — genius (forensic review) + alien (paradigm-breaking) modes
ac-bead-capture	Capture a raw idea/bug/decision on the go as one properly typed, routed bead
beads-standards	Machine-wide bead canon (not pipeline-scoped) — agent vs human bead templates, human-gate label taxonomy + synonym merge map, refined/unrefined semantics, status/priority/close_reason conventions, dependency-wiring requirements
agent-mail	Multi-agent coordination domain — session identity (two-tier contract), file reservations, release/deregister exit, build slots; owner of the session-procedure + agent-identity canons
ac-review	Feature-branch review — parallel reviewers, auto-fix + escalation
ac-land	Session closure — retrospective learning + system compounding
ac-prove	The shared tip-valid full-suite proof primitive — freshness probe / dispatch-if-stale / ensure --fix-forward; every ship path calls it instead of re-implementing its own CI-trust logic
ac-distribute	Native ship mechanics — signed build to TestFlight / App Store submission (the outbound half; ac-triage is the inbound counterpart)
ac-tidy	Pipeline housekeeping — archive done items, reconcile backlog/plans/beads (out-of-band)
ac-hygiene	Iterative codebase cleanup (out-of-band, between waves)
ac-human-session	Human command center — surfaces only work at a human gate (blockers, plans to approve, hopper), conducts the sit-down
ac-dashboard	Read-only full-board dashboard — backlog/plans/beads/WIP at a glance, both sides of the loop boundary; renders, never acts

Engineering (promoted from body-compass-app, the canonical donor)

Skill	What it does
supabase	Supabase CLI, migrations, RLS, Postgres patterns
testing	Vitest unit/component/integration test authoring
capacitor	TypeScript dev in Capacitor (native wrap) projects
planning	Scope-oscillation methodology reference (the lenses the ac-plan-* chain applies — not a direct entry point)
brainstorming	Divergent–convergent pre-planning ideation
jef-flywheel	The agentic build methodology — beads + swarms, setup, lessons (Jeffrey-Emanuel)
jef-prompts	Curated one-shot prompt library (the "jef" pack) — invoke /jef-prompts <hint>
ac-idea-lab	Deep analysis of a raw idea — genius (forensic review) + alien (paradigm-breaking) modes
audit	The audit loop's checklist framework — severity-scored security/performance/tests/qa/ui sweeps of APP code, findings → beads (for auditing this registry itself → ac-registry-audit)
skill-builder	Meta-skill for authoring/refactoring skills — spine+references standard, RED-GREEN testing, validate/init scripts
workflow-builder	Build a new orchestrated multi-step /command workflow — 6-phase build process, run-ledger + phase-skeleton + quality-gate standards
ac-registry-audit	Make the registry itself watertight — audit the prompt corpus for trigger collisions, divergent duplicates, dangling refs, doc↔disk drift; mechanical fixes + gated judgment calls (lint.sh → dedup/drift workflow)
browser-testing	UI/login/flow validation via agent-browser
device-testing	Ad-hoc native iOS-simulator driving via agent-device, with screenshot/video capture — the native twin of browser-testing
ui-brainstorm	Multi-model UI critique with consensus ranking
ui-debug	CSS / visual bug investigation
ac-ui-polish	Conform UI to the app's design.md then polish to premium — whole-app crawl or one screen; anti-slop audit (was ui-elevate)
ac-site-polish	Conform the public marketing site to design.site.md then polish to premium — the public twin of ac-ui-polish
web-design-guidelines	Accessibility, forms, animation, typography UX
app-store-screenshots	Generate iOS App Store screenshots from real screens
screenshot-refresh	Discover, seed, and recapture stale landing page screenshots
seo-metadata	Add or audit SEO and social-share metadata (OG, Twitter cards, JSON-LD, sitemaps)
prompt-enhance	Audit and improve subagent prompts in skill/command files against a research-backed rubric
ac-qa-device	QA the native build on device/simulator — journeys, native shell, appearance matrix, screenshots/video
ac-qa-browser	QA the web build in a browser (the twin) — journeys, web shell, console, responsive, screenshots

ac-distribute/ also carries references/_DECISION-distribution-stack.md — the distribution-stack decision doc (ratified 2026-06-15) that preceded the skill.

Not promoted (stay per-app): CORE, brand, design-system (pillar-color-coupled), writing-guidelines (brand-voice-coupled), curate — these are project/brand-specific and can't have one shared version.

Substrate — the AI-native-org memory skills (deploy together)

Skill	What it does
context-engineering	Canonical save-routing taxonomy and L0–L4 loading model — where durable knowledge goes and what loads when
memory-pipeline	How the compounding system RUNS — the three lanes (L3 memory, skill frictions, wiki synthesis), their executors, cadence, drains, and health surface (operations; the taxonomy stays in context-engineering)
reflect	Capture session learnings into the memory substrate — facts, decisions, recipes, domain-routed and git-tracked
dream	The org's self-improvement engine — synthesize cross-session patterns, lint the substrate, emit PR-style proposals
wiki	Write and garden wiki synthesis pages — concept/entity/topic/contradiction pages that integrate atomic facts and decisions into one cited narrative (a derived view, not fact capture)

Commands → Skills (migration complete)

Anthropic merged custom commands into skills (a commands/x.md and a skills/x/SKILL.md both create /x). The migration is done: the engineering workflow commands became the Pipeline skills above, and the jef prompt pack became the jef-prompts skill. Everything deploys as a skill via deploy.sh --skills; one legacy file remains under commands/jef/.

Prompts

The jef-prompts skill is a curated library of high-leverage one-shot prompts (debugging, performance, refactor, planning, ideation, review, UI, workflow). Invoke /jef-prompts <hint> and it loads the best-matching prompt from skills/jef-prompts/references/.

Agents

Portable agent definitions, symlinked into .claude/agents/.

Agent	What it does
researcher	Read-only gather-and-distill stance — investigates the brain, codebase, and web; never writes
implementer	Production stance — scoped execution of approved plans/specs (code, content, config)
validator	Adversarial verification stance — audits/judges work against rubrics, finds issues, never fixes
tester	Test coverage and validation specialist — verifies test quality and runs automated suites
code-explorer	Read-only codebase exploration + mapping, pattern discovery before building
browser-tester	UI smoke testing via agent-browser — runs user journey story files and reports PASS/FAIL
browser-agent	General-purpose headless browser automation — screenshots, scraping, forms, navigation
device-tester	Native UI validation agent — runs journeys in the iOS Simulator via agent-device + simctl, reports PASS/FAIL, never edits code

Note: implementer and validator were formerly named engineer and reviewer — those aliases are retired.

Quick Start

Deploy with deploy.sh (selective one-offs)

For the standard full sync — all targets, all harnesses (Claude/Codex/Droid/Pi skills, agents, hooks, MCP) — use ./harness-sync.sh --all instead; it drives deploy.sh internally and runs daily via infra-sync. deploy.sh alone is for stamping a chosen subset into one project's .claude/.

# See everything available
./deploy.sh --list

# Stamp a project with a chosen subset (symlinks, never copies)
./deploy.sh ../my-project \
  --skills supabase,testing,planning,jef-prompts --agents engineer,reviewer

# Or take everything
./deploy.sh ../my-project --all

# Preview without writing
./deploy.sh ../my-project --all --dry-run

deploy.sh computes relative symlinks automatically and refuses to overwrite a real file already at the target — so it never clobbers a project's customized skill. Each skill lands as .claude/skills/<name>/ and is invoked as /<name> (e.g. /ac-plan, /jef-prompts).

Then create the project's context file:

cp templates/project-AGENTS.md ../my-project/AGENTS.md   # fill in stack + conventions
mkdir -p ../my-project/_backlog ../my-project/_plans ../my-project/_strategy

Skills setup

export OPENROUTER_API_KEY=sk-or-...  # for openrouter / expert-consensus

Claude Code discovers each SKILL.md automatically. Use e.g. /expert-consensus What makes a great API? — toggle models in skills/expert-consensus/expert-panel.json.

Dependencies

Dependency	What it provides	Install
beads (br)	Artifact-based planning and implementation tracking — plans, beads, pipeline stages	cargo install --git https://github.com/Dicklesworthstone/beads_rust.git
agent-mail (MCP)	Inter-agent messaging, file reservations, coordination for multi-agent workflows	Add as MCP server in .claude/settings.json
openrouter	OpenRouter CLI for multi-model queries (used by expert-consensus and openrouter skills)	Install the openrouter CLI and ensure it's on your PATH
agent-browser	Headless browser automation CLI for UI testing (used by browser-tester sub-agent, ac-land, ac-review)	npm install -g agent-browser

Philosophy

• Compound, don't collect — each skill should make the next one more valuable
• SKILL.md is the interface — human-readable reference that doubles as AI context
• Standalone by default — no frameworks, no setup wizards
• One config file per skill — e.g. skills/expert-consensus/expert-panel.json

License

MIT