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.
Symlinked into a project as .claude/skills/<name>/.
The registry is seven packages (map generated from skills/packages.json by
scripts/render-readme-packages.py — edit the manifest, then re-run; never hand-edit
the map). Stage order — stage · owner · trigger · human gate · artifact — lives in
skills/ac-pipeline/references/stage-table.md; nothing here restates it.
factory-core — the production line (conductor: ac-implement; doctrine: ac-pipeline).
| Skill | What it does |
|---|---|
| ac-pipeline | The pipeline CONSTITUTION + the operating contracts. Constitution: Invariants (hold at any model capability) + Calibrations (each naming the telemetry that retires it) — read before writing, tuning or reviewing any lean-pipeline skill or script. Triggers: "pipeline constitution", "pipeline invariants", "tune the pipeline", "ac-pipeline". Operating contracts: the owner-hosted runtime canons every ceremony consults live in references/ of this same skill (commit-discipline, delegation-contract, run-ledger, run-id, verification-gate, board-scan, risk/consensus/disposition, degraded-mode, shell-guardrails), the QA methodology lives in ac-qa/references/qa-shared.md, and the deterministic gates live in scripts/ (beads-closed-gate, validate-qa-run, close-evidence-check, board-truth). NOT for RUNNING anything: one stage (that stage''s own skill), or a gate/script this skill merely hosts (the calling ceremony fires it). |
| ac-plan | Turn an idea into ONE ac2 plan file — problem, approach, deliverables, assumptions, risk + sequence, out-of-scope, and a success criterion that can come out FALSE. Explorers optional, chosen by size. Triggers: "ac2 plan", "write an ac2 plan", "plan this for ac2". Polishes and approves in-session, then asks to start beadify. |
| ac-polish | Polish a plan, an epic''s bead set, or a code scope to FIXPOINT — a stateless severity-gated reader per round, stamped only against a measured empty diff at round >= 2. One engine, six modes, selected by argument; seams mode traces one object through three lenses (object · flow · boundary), converges on the merged maps, and derives its seams into a plan. Triggers: "ac2 polish", "polish the plan", "polish the beads", "polish this code", "refine the ac2 beads", "run polish to fixpoint", "ac-seams", "study the seams of", "seams plan for". |
| ac-beadify | Compile an APPROVED ac2 plan into lean beads — the four-section ac2 schema, a wired dependency graph, and plan retirement. Refuses any bead whose ACs name no executable probe (no probe, no bead). Triggers: "ac2 beadify", "compile the plan into ac2 beads", "ac2 beads from plan". To grade the result use ac-polish. |
| ac-implement | Work an ac2 epic''s bead queue as a SWARM — you coordinate, spawned workers claim, flight check, RED, implement, self-review, close gate, next bead. Defaults to width 3, uncapped, until the qualifying beads are exhausted. Triggers: "ac2 implement", "work the ac2 beads", "run the ac2 loop", "swarm the ac2 beads", "ac2 swarm". |
| ac-review | The hand-run independent review: ac-review <range> over a range the operator names — nothing triggers it and no batch runs it. Three lenses (correctness against the plan and the bead ACs, test-quality, and one risk lens the diff chooses) report against one bar: a demonstrated failure in ordinary operation, or a violated acceptance criterion, with a reproducing command. Every finding routes to Defect (a bead), Hardening (one report line, never a bead) or Nothing; a fresh verifier re-runs each Critical/High before any fix. Reviewers run the validator stance, read-only on the shared tree; reports land in .claude/reviews/. Triggers: ''/ac-review'', ''review the batch'', ''review this range''. |
| ac-prove | Use to obtain-or-produce a tip-valid full-suite proof for a commit — the shared freshness-probe/dispatch/fix-forward primitive every ship path calls instead of re-implementing its own CI-trust logic. Wraps scripts/ci/publish-checkpoint-gate.mjs (freshness) + quality-gate.yml's reason=prove dispatch (the full leg). Three modes — probe (read-only), ensure (probe + dispatch-if-stale), ensure --fix-forward (blocking, ship-path only). Triggers on "prove this commit", "ac-prove", "is main green", "get a fresh checkpoint", "prove the tip", "gate on a full proof". NOT for running tests locally (use testing) or for reading CI state as a board pane (use ac-board). |
| ac-publish | The ac2 ship gate — obtain a proof via ac-prove, assert its REQUIRED JOBS ACTUALLY EXECUTED, then version, tag the proven SHA and hand off to ac-distribute; labels external escapes with a catch-stage on arrival. Triggers: "ac2 publish", "ship the ac2 batch", "release this batch" — run by the operator once a batch is ready to ship. NOT the proof itself (ac-prove), NOT the store upload (ac-distribute). |
| ac-land | The closing ritual — runs LAST, after ship. To land = leave it clean AND wiser: TEARDOWN (kill spawned tasks, sweep orphaned waiters, release+deregister Agent Mail, clear temp, clean tree) plus LEARN (retrospective + reflect + system compounding). Triggers: 'land the session', 'bead land', 'close out the bead work', 'wrap up session', loop exit. NOT for standalone lesson capture without bead-work context (that is reflect). |
| beads-standards | Use when creating, refining, or reviewing a bead in ANY .beads/ project — choosing a label, deciding refined vs unrefined, writing a human-gate/DECISION bead, wiring blocks dependencies, setting close_reason or defer_until, or picking priority/status. Triggers: "beads standard", "bead template", "human-gate", "DECISION bead", "HUMAN bead", "create a bead", "close reason", "refined unrefined", "wire dependencies", "which label". Canon for every repo with a .beads/ directory (root, every app, agent-compounds, any other task tracking) — not scoped to the agent-compounds ac-* pipeline (that pipeline''s own batch-epic + routing supplement lives in skills/beads-standards/reference/bead-conventions.md; read both inside an ac2 skill). This is the STANDARD, not an executor: to actually refine a bead use ac-polish, to capture one use ac-backlog, to generate a wave use ac-beadify. |
| agent-mail | Multi-agent coordination via Agent Mail — registering a session identity, reserving files before editing a shared checkout, releasing + self-deregistering at exit, build slots, messaging. Use when starting any session that will commit code alongside concurrent agents, when hitting FILE_RESERVATION_CONFLICT or a pre-commit guard block, or when choosing between a minted Tier-1 identity and the FoggyCreek chore fallback. Triggers: "register agent identity", "reserve files", "file reservation", "agent mail", "macro_start_session", "release reservations", "deregister agent", "build slot", "FoggyCreek". NOT for commit discipline itself (that is ac-pipeline references/commit-discipline), for choosing a delegation stance (ac-pipeline references/delegation-contract), or for actual email/outbound comms (ac-distribute). |
budget: spine ≤1800, loaded ≤14000 · requires: ship
factory-verify — QA journeys, UI elevation, tests, hygiene.
| Skill | What it does |
|---|---|
| ac-qa | Use when QA-ing an app build through journeys — browser (web shell) or device (native shell). One engine, two workflows: workflows/browser.md (agent-browser — SPA routing, storage/session, service worker, CORS, console, hydration, responsive) and workflows/device.md (agent-device + simctl — real native taps, keyboard, safe-area, splash, plugins, system sheets, deep links, push, appearance). Depth levels, journey reuse, findings=beads, and the conductor/worker evidence protocol are shared. Triggers on "QA the app", "test web app", "browser QA", "device QA", "simulator QA", "test native app", "validate the build", "web smoke test", "native smoke test", "QA on iOS". NOT for writing unit/component/E2E tests (testing), ad-hoc UI bug repro (ui-debug), or visual polish (ui-elevate). |
| ui-elevate | Use when raising already-working UI to premium quality — the taste layer above correctness. Two modes: app (the authenticated product surface) and site (the public marketing surface). Triggers on "polish this UI", "elevate this screen", "make it feel premium", "level up the design", "polish the landing page", "elevate the homepage", "the website looks like AI slop", "tighten the visuals", "make it production-quality", "audit the design craft". Covers the elevation manifesto, anti-slop critique, visual craft, interaction and feel, perceived performance, and conversion craft, with every edit bounded to the design spec''s tokens. NOT for: functional or correctness defects (ac-polish ui mode), accessibility mechanics (ac-polish/references/ui-checklist.md), React/Next perf internals (capacitor), visual/CSS bugs (ui-debug), or multi-model design ideation (ui-brainstorm). |
| ui-debug | Debug UI bugs, CSS styling issues, and unexpected visual behavior in React/Next.js apps. Use when elements render wrong, styles do not apply, or layout breaks across viewports. Triggers on CSS bug, style not applying, layout broken, element misaligned, rendering issue, responsive bug, flexbox/grid issue, visual regression. NOT for premium polish (ui-elevate), a failing visual-regression test (testing, ac-qa), accessibility (ac-polish/references/ui-checklist.md), or performance (capacitor). |
| testing | Use when writing, fixing, or reviewing tests for TypeScript/Next.js code — unit, component, integration, or E2E tests. Triggers on test, spec, coverage, mock, assertion, Vitest, Playwright, React Testing Library (RTL), MSW, flaky test, failing test, write a test, add test coverage. NOT for ad-hoc browser or simulator runs (the ac-qa driver references), pipeline-gated QA (ac-qa, ac-qa), or security/performance sweeps (audit). |
| ac-hygiene | The single code-quality lane — a 5-lens Opus panel (bug hunter, adversary, failure engineer, promise keeper, test warden), minimum 3 rounds for cross-round consensus, scoped to code a user reaches in production. Audits the TEST SUITE as hard as the code: test-quality checks; mutation probes convict hollow tests and trimming counts as much as fixing. Fixes commit directly to main (trunk-direct); deferred findings become an epic of beads. Triggers: ''hygiene'', ''clean up the codebase'', ''iterative review'', ''tidy the code'', ''weekly hygiene run''. NOT for a single-module or single-domain deep dive (the audit checklists now live in ac-review/references/), the skill/agent registry (skill-builder's registry-audit workflow), or pipeline/board housekeeping (use ac-tidy). |
budget: spine ≤1000, loaded ≤11000 · requires: design_spec, journeys_dir, routes_manifest, routes_public_manifest, ui_audit, serve_prod
factory-ops — human command center, align, backlog intake, triage, native distribute.
| Skill | What it does |
|---|---|
| ac-human | The human command center — sit down and keep the factory moving. Opens with the full board (invokes ac-board), then drives the docket: only work at a human gate, on a silver platter, exit-first. Optional gated tidy/align pre-pass. Triggers: ''human session'', ''what needs me'', ''sit down'', ''unblock work'', ''my action items'', "what''s blocked on me", ''keep the factory moving'', ''human next''. ''Unblock'' means a HUMAN gate only — NOT a technical blocker (use ac-backlog to file it, or ac-triage for inbound signal), and NOT doing the work itself (use ac-implement). |
| ac-align | Align the execution pipeline against current strategy — audit backlog/plans/beads for fit, sequence, and gaps, and own pool → active promotion (binding versions late, against live strategy). Owns the weekly strategy-align heartbeat. Triggers: ''align pipeline'', ''pipeline alignment'', ''is my pipeline on strategy'', ''audit backlog against goals'', ''what should we plan next''. NOT for what to work on NOW (use ac-board to read the board, ac-human for the gated docket), for working the idea/strategy itself (use ac-idea-lab), for board housekeeping (use ac-tidy), or for codebase cleanup (use ac-hygiene). |
| ac-tidy | Pipeline housekeeping — reconcile backlog, plans and beads against live state: archive what is done, repair statuses and readiness labels, remove invalid labels, close moot proposals, and file a bead for anything that needs a human. Interactive on request; the nightly heartbeat runs it headless. Triggers: ''tidy the pipeline'', ''clean up the backlog'', ''reconcile plans and beads'', ''archive what is done'', ''fix bead labels''. NOT for strategy fit or pool → active promotion (ac-align), reading the board (ac-board), the human docket (ac-human), or code cleanup (ac-hygiene). |
| ac-backlog | Capture ideas into the backlog pool — cohesive grouping (one theme = one wave), shape-routing (small+clear goes straight to a bead), strategy-aware horizon, no version guessing at capture. Also the single-bead intake: one raw idea, bug, observation or decision fork typed live in conversation and filed now as a bead carrying origin:ac-backlog. Triggers: ''add to backlog'', ''capture idea'', ''backlog this'', ''note for later'', ''park this'', ''bead this'', ''file this as a bead'', ''new bead'', ''log a bug'', ''track this item'', ''remember to do X''. For decomposing a whole plan use ac-beadify; for refining existing beads use ac-polish (bead mode); for polling external systems use ac-triage. |
| ac-triage | Use to pull operational + user signal BACK IN from external systems — crashes, errors, logs, beta feedback, externally-filed issues — cluster it, and route real findings by shape — defects to beads, recurring feature/experience themes to the backlog pool (as candidates the human approves). Fetches from Sentry, App Store Connect (TestFlight feedback), Supabase logs, GitHub Issues, PostHog, store reviews. The inbound counterpart to ac-distribute. Triggers on "triage crashes", "check sentry", "any new errors", "pull feedback", "triage github issues", "what's breaking in prod", "triage production signal", "review crash reports". Headless — runs anywhere, scheduled. NOT for triaging the bead board itself — that is bv (read-only) or ac-polish (bead mode). |
| ac-distribute | Use to SHIP a built app out the door — push a signed build to TestFlight (closed beta), or submit a release to the App Store. The ship-OUT stage of the ac-* pipeline — position per ac-pipeline/references/stage-table.md; the hand-off target of the ac-publish release gate. Triggers on "ship to testflight", "push a build", "release to app store", "cut a build", "distribute the app", "submit for review". For pulling crashes/feedback BACK IN → ac-triage. For proving the build first → ac-qa. For the full production release gate (version bump, proof, tag) before this → ac-publish. |
budget: spine ≤900, loaded ≤4000 · requires: store, triage, human
stack-nextjs-supabase — the Next.js + Supabase + Capacitor stack.
| Skill | What it does |
|---|---|
| supabase | Supabase development. Use when writing or reviewing SQL and migrations, designing or modifying database schema, working with RLS policies, optimizing queries or indexes, using the Supabase CLI (supabase db, supabase migration), generating TypeScript types from schema, debugging database or auth issues, or touching lib/db.ts, lib/supabase/, or supabase/migrations/. NOT for UI component work (use ac-polish/references/ui-checklist.md for correctness, ui-elevate for polish), general React patterns or device storage (use capacitor), or auth UI flows (use CORE + auth spec). |
| capacitor | Use for ALL engineering decisions when building Capacitor native apps on the shared stack (Next.js static export + React + SWR + Supabase) — load before planning or implementing any UI, navigation, data fetching, auth, storage, lifecycle, or build work. Triggers on "capacitor", "native app", "iOS", "Android", "native feel", "tab switch", "keep-mounted", "WKWebView", "skeleton flash", "SWR cache", "static export", "cold start", "app lifecycle", "Preferences storage", "plugin", "native performance", "background", "app resume", "safe area", "tab navigation", "plugin bridge", "MainActor", "visibility hidden", "display none". NOT for writing or fixing tests (use testing), SQL/schema/RLS/migrations (use supabase), visual or CSS defects (use ui-debug), or accessibility audits (use ac-polish/references/ui-checklist.md). |
budget: spine ≤1100, loaded ≤6000
substrate — the AI-native-org memory skills (deploy together).
| Skill | What it does |
|---|---|
| context-engineering | The canonical context + memory architecture for the AI-native org. Use when deciding WHERE or HOW to save something durable (a lesson, decision, rule, recipe, doc), when asked "where should this live", "how do we store/remember X", "what loads when", "how does memory actually work", or when designing/auditing anything touching memory, CLAUDE.md/AGENTS.md, CORE, skills structure, hooks, or retrieval. How the compounding system RUNS — the three lanes, their executors, cadence, drains, health surface ("memory pipeline" questions) — lives in references/operations.md. NOT for executing a save at session end (that is reflect), cross-session synthesis or memory lint (that is dream), or plain file/folder organization on disk (no skill needed). |
| reflect | Capture session learnings into the AI-native-org memory substrate. Use at the end of any session, or when asked to "reflect", "capture learnings", "what did we learn", "save lessons", "remember this", "compound this session". Called by ac-land; also runs standalone. NOT for full bead-work closure (that is ac-land), cross-session synthesis/lint (that is dream), or deciding WHERE something durable should live (that is context-engineering). |
| dream | Run the dream session — the org's deliberate self-improvement review, human-run and unscheduled. Use when asked to "run the dream cycle", "dream", "synthesize the week's lessons", "lint the memory substrate", "review dream proposals", "review the dream dockets", or "what did the dream cycle find"; also when a docket-review bead is open. The session reads both ranked dockets (memory-rollup — knowledge substrate, friction-rollup — friction ledger, both computed live), rules each item with the human, and emits approved work as task beads. NOT for capturing one session's lessons (that is reflect) or saving a single item (that is context-engineering routing). |
| wiki | Use when writing, updating, or gardening wiki synthesis pages — concept, entity, topic, or contradiction pages integrating atomic facts into one cited narrative. Triggers on "wiki page", "synthesis page", "seed a wiki page", "garden the wiki", "concept page", "entity page", "contradiction page", "write X up as a wiki page", "dedupe the wiki", "WIKI.md front door", "weekly distillation", "STRATEGY.md decisions log". NOT for saving one fact/rule/decision (context-engineering), session-end capture (reflect), or the weekly cross-session synthesis run (dream). |
budget: spine ≤1100, loaded ≤3000 · requires: memory, human
meta — authoring and auditing the registry itself.
| Skill | What it does |
|---|---|
| skill-builder | Use when creating, editing, refactoring, or cleaning up skills — dieting a SKILL.md to its spine, extracting references/, centralizing shared blocks, optimizing description cost, building an orchestrated /command or scheduled workflow (run ledger, phases, quality gates), scoring subagent prompts against a rubric, auditing the skill registry for trigger collisions, duplicates, and doc-disk drift. Triggers on "create a skill", "build a skill", "refactor this skill", "clean up our skills", "skill hygiene", "diet this skill", "extract to references", "convert to a skill", "description budget", "build a workflow", "create a /command", "turn this SOP into a command", "design a pipeline command", "workflow builder", "enhance prompts", "improve subagent prompts", "score my prompts", "prompt quality review", "rate this prompt", "registry audit", "audit the skill registry", "registry hygiene", "dedup the skills", "skill collision check", "clean up agent-compounds". NOT for a canned prompt (use jef-prompts). |
budget: spine ≤600, loaded ≤7000
library — one-shot prompts, methodology, labs, multi-model access, UI critique.
| Skill | What it does |
|---|---|
| jef-prompts | A curated library of high-leverage one-shot prompts — the Jeffrey-Emanuel jef pack plus local additions. Triggers: "/jef-prompts ", "give me a prompt for", "is there a prompt for", "bug hunting prompt", "planning prompt", "performance audit prompt", "refactor prompt", "find a prompt". RETRIEVES a canned prompt — NOT for scoring or improving prompts already written (skill-builder's prompt rubric) or authoring skills (skill-builder). |
| jef-flywheel | Use when learning or applying the agentic build methodology end-to-end — beads (br/bv) and agent-swarm (ntm) setup, coordinating multi-agent work, AGENTS.md conventions. The conceptual/setup layer, not the per-stage pipeline skills. Triggers on flywheel, agent swarm, ntm, br/bv setup, agent coordination, multi-agent development. To convert a plan into beads use ac-beadify; to run a stage use the ac-* skills; for live coordination (identity, file reservations) use agent-mail; for bead canon use beads-standards. |
| brainstorming | Pre-planning exploration and ideation using divergent-convergent methodology. Use when exploring ideas before committing to a plan or uncertain which approach to take. Triggers on "brainstorm", "explore ideas", "what are the options", "think through approaches", "before I plan this", "/brainstorm". NOT for UI/design ideation across models (ui-brainstorm), forensic critique of an existing idea (ac-idea-lab), or polling models on one question (multi-model). |
| ac-idea-lab | Use to deeply work a raw IDEA, framework, concept, or strategy (anything without execution steps yet) — two modes: GENIUS forensic first-principles critique (stress-test, find flaws, distill) and ALIEN paradigm transcendence (escape the frame, cross-domain transplants, expand). Triggers on "review this idea", "stress-test this", "devil's advocate", "critique this concept", "find flaws in this", "first-principles review", "transcend this idea", "go deeper", "push beyond analysis", "alien perspective", "escape local optima", "what am I missing at a deeper level". For a written implementation plan with steps/timelines use ac-plan-lab; for open-ended generation of new options use brainstorming; for a multi-model panel use multi-model. |
| ac-plan-lab | Use to deeply pressure-test and elevate a written implementation PLAN, roadmap, or strategy (steps/timelines/resources) — two modes: GENIUS forensic first-principles critique (find flaws, stress-test assumptions, reconstruct) and ALIEN paradigm transcendence (escape the frame, cross-domain transplants, future-proof). A review gate in the planning chain. Triggers: ''genius review the plan'', ''pressure-test this plan'', ''find flaws in the plan'', ''forensic plan review'', ''transcend this plan'', ''push the plan deeper'', ''alien perspective on the plan'', ''escape local optima on this plan'', ''what is the plan missing''. For a raw idea or concept (no execution steps) use ac-idea-lab. |
| multi-model | Use when a task needs a specific AI model or several weighing in on one question — query Claude, GPT, Gemini, Grok or DeepSeek directly, or get a multi-model panel synthesized into one answer on OpenRouter Fusion. Triggers on "query a model", "which model for", "use OpenRouter", "ask GPT/Gemini/Grok directly", "run this on ", "ask the experts", "model consensus", "panel of AI models", "second opinion from other AIs". NOT for UI/design options (ui-brainstorm), forensic idea critique (ac-idea-lab), or Anthropic API/model reference (claude-api). |
| ui-brainstorm | Use ONLY when the user explicitly wants MULTIPLE divergent design options or several AI models'' opinions on a UI — design ideation, exploring alternatives, or cross-model consensus ranking. Triggers on "ui brainstorm", "design options", "multiple ideas", "explore alternatives", "what would different models suggest", "consensus on this design". NOT for single-track polish of existing UI (ui-elevate), accessibility/compliance audits (ac-polish/references/ui-checklist.md), or visual/CSS bugs (ui-debug). |
budget: spine ≤1300, loaded ≤18000
ac-distribute/also carriesreferences/_DECISION-distribution-stack.md— the distribution-stack decision doc (ratified 2026-06-15) that preceded the skill.
Unpackaged:
ac-board— read-only factory window: one glance at the whole pipeline (human gates, plans by stage, beads by stage, WIP + CI health, active agents); observes only, never writes. It belongs to no package.
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.app-store-screenshots,screenshot-refresh,seo-metadata— app asset + marketing-SEO concerns, owned by each app (a consuming app may keep its own reference copy rather than promoting them here).
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 factory-core 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/.
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/.
Portable agent definitions. Each declares a semantic tier: (orchestrator | coordinator | worker — never a concrete model); deploy.sh generates them into .claude/agents/ with the model stamped per harness from harnesses.json agent_models, so the same tier can mean opus/sonnet in Claude Code and any OpenCode Go model — or inherit, which leaves model: off so the stance runs on the session's model — under OpenCode. The tools: boundary is enforced only by Claude Code; opencode reduces it to an edit allow/deny, and the codex/droid projections carry the stance text alone — on those harnesses the prompt is the boundary. scripts/stance-spawn.test.sh is the live check that each stance spawns and writes scratch.
| Agent | What it does |
|---|---|
| orchestrator | Fleet-conductor stance — plans, sequences, delegates, holds decisions and batch boundaries; never implements |
| coordinator | Judgment stance — looks, understands, critiques, synthesizes; edits the artifact it judges when asked, no mechanical execution |
| researcher | Gather-and-distill stance — investigates the brain, codebase, and web; writes only scratch and its digest |
| 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 |
Consolidation rule (2026-09-07): the fleet carries exactly these five stances — stance = who, tier = model strength, domain = a lens prompt from the skill that needs it (QA journeys, browser automation, test writing all ride implementer/validator prompts). The former
tester,code-explorer,browser-agent,browser-tester,device-tester, andreview/*agent files were folded: spawning a new agent file for a new domain is now the wrong move — write a lens prompt instead.implementerandvalidatorwere formerly namedengineerandreviewer— those aliases are retired.
This repo reads this machine's facts from one gitignored file at its root: machine.json
— the org root, the app targets the installer stamps, and any harness overrides merged
over harnesses.json. It is edited by hand (there is no writer) and engine/machine.sh
is its only reader; copy the committed example and edit it:
cp machine.example.json machine.jsonengine/machine.sh exits 4 (NOT-CONFIGURED) when the file is absent and 2
(CONFIGURED-BUT-WRONG) naming the key and the path when it is present but wrong.
For the standard full sync — all targets, all harnesses (Claude/Codex/Droid/Pi skills, agents, hooks, MCP) — use
./harness-sync.sh --allinstead; it drives deploy.sh internally and is meant to be wired into a recurring sync job (yours to schedule) rather than run by hand every time. 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,jef-prompts --agents engineer,reviewer
# Or take everything
./deploy.sh ../my-project --all
# Preview without writing
./deploy.sh ../my-project --all --dry-rundeploy.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/_strategyexport OPENROUTER_API_KEY=sk-or-... # for multi-modelClaude Code discovers each SKILL.md automatically. Use e.g. /multi-model What makes a great API? — direct query or panel synthesis via OpenRouter Fusion (skills/multi-model/workflows/fusion.md).
Every dependency below is optional — you can adopt this registry without installing any of them first. A skill that calls one and finds it missing is written to degrade loudly (skip the step, say why, keep going) rather than silently no-op. A few are the author's own unpublished tools; those are named honestly below so you know what a fresh clone is missing, not because you can go install them.
| Dependency | What it provides | Install |
|---|---|---|
| beads (br/bv) | Artifact-based planning and implementation tracking — plans, beads, pipeline stages. The ac-* pipeline skills assume it; without it, bead-based stages have nothing to read/write |
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 |
| agent-browser | Headless browser automation CLI for UI testing (used by implementer workers on browser journeys, ac-land, ac-review) | npm install -g agent-browser |
| openrouter | CLI for multi-model queries (used by the multi-model skill) | Install an openrouter CLI and put it on your PATH — this is the author's own unpublished wrapper over the OpenRouter API; without it, multi-model has nothing to call |
| ubs | Meta-linter that gates commits across changed files, invoked by pipeline commit-discipline doctrine | Author's own unpublished tool; skills that call it degrade to skipping the gate |
| qmd | Memory/recall CLI — queries the facts/rules/wiki memory substrate | Author's own unpublished tool; recall calls degrade to "no hits" rather than failing |
| cass | Past-session search CLI | Author's own unpublished tool; same degrade-to-empty behavior as qmd |
| slack-send | Sends a notification to a chat channel from a headless/scheduled skill run | Author's own unpublished tool; calls degrade to skipping the notification |
| outputs | A local output-routing helper referenced by a handful of skill workflows | Author's own unpublished tool; degrades to a no-op where referenced |
| ntm | Multi-agent/tmux swarm orchestration helper referenced by jef-flywheel's methodology docs | Author's own unpublished tool; not required to use the ac-* skills themselves |
| pai-scheduler | Job scheduler used to run headless/scheduled skill invocations (e.g. triage or tidy heartbeats) | Author's own unpublished tool; substitute cron or any scheduler — the skills just need something invoking them on a cadence |
| dcg (destructive-command guard) | A pre-tool-use hook that blocks destructive shell commands before they run | Third-party binary; fails open if missing (never blocks) — see engine/hooks.wiring.json if you deploy hooks |
- 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 workflow file per skill — e.g.
skills/multi-model/workflows/fusion.md
MIT