team
Skill0 starsChanged 7 days agoMITView on GitHub
Agent team for Claude Code: Antigravity CLI (agy) drafts the product plan, Claude designs and reviews, an Orca worker builds (Claude Sonnet, or another agent the user names, e.g. agy). Feature: product plan (when users see the change) -> design doc -> independent read-only review (+ a risk reviewer for money, auth and, except before launch, data-changing migrations) -> user approval -> the worker implements -> code review by a different model + ponytail -> report. Founded services build a milestone at a time: one milestone design, one review, one approval, then its slices back to back and one review of the whole milestone alongside its full test suites. Foundation mode ("/team foundation <service>") drafts the charter, the expensive-to-reverse decisions and the milestone map with the user. Triggers: "/team", "/team foundation", "/team M3" (a milestone or slice), "design then have a worker implement it", "have sonnet implement this", "implement with agy", "work as a team", "design the whole service from scratch", "re-check what /team built". Trivial edits (1-2 files) don't need a team - just do them. If you are running /team and the conversation was compacted, re-read this skill once before the next step.
50 other projects use a version of this.
Adopted by
Most recently taken up by
- ddivyanshsharmaa/fable-toolkittheir own version, first seen Nov 16, 2026
- shanren/maestrotheir own version, first seen Nov 16, 2026
- Yomudogly/oh-my-agytheir own version, first seen Nov 16, 2026
- kele-dev/Claude-Orchestrator-Skilltheir own version, first seen Nov 16, 2026
- esbenboye/ClaudeCodetheir own version, first seen Nov 15, 2026
- Yeachan-Heo/oh-my-claudecodetheir own version, first seen Nov 9, 2026
Used with
Projects with it also use community-led-growth, ph-community-outreach and 10 more.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
nicepkgSkillcommunity-led-growth
Expert in community-led growth (CLG) - leveraging user communities to drive acquisition, retention, and expansion. Covers building developer communities, user groups, ambassador programs, and turning customers into advocates. Knows the difference between community as a feature vs community as a growth engine, and how to measure community ROI. Use when "community-led, CLG, ambassador program, champion program, user community, developer community, word of mouth, user group, " mentioned.
Also in 5 projects that use this
nicepkgSkillph-community-outreach
Engage Reddit, Indie Hackers, Hacker News and other communities for Product Hunt launches. Use this skill to identify relevant communities, craft appropriate posts, and drive cross-platform engagement without appearing spammy.
Also in 5 projects that use this
xfstudioSkillmicro-saas-launcher
Expert in launching small, focused SaaS products fast - the indie hacker approach to building profitable software. Covers idea validation, MVP development, pricing, launch strategies, and growing to sustainable revenue. Ship in weeks, not months. Use when: micro saas, indie hacker, small saas, side project, saas mvp.
Also in 5 projects that use this
mastepanoskiSkillux-audit-rethink
Comprehensive UX audit using IxDF's 7 factors, 5 usability characteristics, and 5 interaction dimensions. Holistic evaluation with redesign proposals based on user-centered design principles.
Also in 5 projects that use this
ibahgatSkillralplan
Create a strict, quality-first execution plan with explicit gates and rollback-ready sequencing.
Also in 8 projects that use this
ncklrsSkillseo-content-strategist
Expert SEO content strategy for SaaS and B2B sites. Use when doing keyword research, planning content clusters, creating pillar pages, optimizing on-page SEO, fixing technical SEO issues, building links, refreshing content, implementing programmatic SEO, mapping search intent, optimizing for SERP features, or measuring content performance. Use for SEO audits, content gap analysis, and organic growth strategy.
Also in 5 projects that use this
- +6 more from nicepkg
Other versions50 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 50
- Yeachan-Heo/oh-my-claudecode★ 41ksame name
- Yeachan-Heo/oh-my-claude-sisyphus★ 41ksame name
- Yeachan-Heo/oh-my-codex★ 34ksame name
- MaxMiksa/Auto-Company★ 3.2ksame name
- MaxMiksa/Autonomous-Company★ 3.2ksame name
- zereight/gitlab-mcp★ 2.1ksame name
- nicepkg/ctxport★ 629same name
- ansari-project/codev★ 298same name
- cluesmith/codev★ 298same name
- shenysun/skills-manager★ 243same name
40 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
The file
We split this skill into the rules it gives an agent
7 rules. 0 are common, 2 are distinctive, and 5 are very specific to this project.
0
Common
Most of the 36 edited versions we read keep these.
2
Distinctive
This author's own choices. Worth a look.
5
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 87
Only an explicit "proceed without approval" in the request skips the gate.
- Very specific: line 96
Independent review: Every design and every diff is reviewed by a read-only team-reviewer subagent.
- Very specific: line 157
Never work around it with web search.
- Distinctive: line 201
Start (one run per feature or milestone):
- Very specific: line 217
Wait: orca orchestration check --wait --types worker_done,escalation,question --timeout-ms 540000 --json (Bash timeout 600000).
- Very specific: line 319
Never Plan: one-shot, no agent ID.
- Very specific: line 331
Never type /ponytail…, "stop ponytail" or "normal mode" as a prompt — it flips ponytail's global mode.
“Common” is measured: kept by at least 6 in 10 of the 36 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
/team — agy plans, Claude designs and reviews, a worker builds
For Claude Code only (another agent reading this folder stops and tells the user). Write to the user in
their language, including template headings; this file, its templates, Orca notices and subagent
results being in English changes nothing. Write every subagent prompt (survey, reviewers) and worker
spec in the user's language and ask for the answer in it, keeping template headings such as
## Verdict: as written: English results are what pull the replies into English.
After a compaction (the conversation continues from a summary) Claude Code keeps only about
the first 5,000 tokens of this file — the later Rules (from about Tests on), the Feature steps, the
Orca worker commands, every template and the gotchas may be gone — and foundation.md only as a
path. Re-read this file in full once per compaction, and in a milestone run the foundation.md
section you are in, before your next step.
Route
- A request to re-check or re-review work this skill already reported ("check it thoroughly")
→ Feature step 6 again with fresh reviewers: a feature with template C, a milestone with the
milestone review's reviewers and prompt (
foundation.mdBuild) minus its no-tests line. Claude makes the accepted fixes itself (no worker round; left uncommitted), aftergit add -A(staging, not a commit) sogit diffshows only them; a reviewer on another model than Claude's re-checks them against the findings,ponytail-reviewruns on that diff and the tests Rules: Tests names re-run; report T. /team foundation …, a new service, or a re-founding →foundation.md"Found".docs/design/foundation/exists and the request names a milestone or slice →foundation.md"Milestone run". A request that changes the foundation →foundation.md"Change".- Anything else → Feature below (in a founded repo it reads the charter, accepted decisions and
slices.mdfirst; the design cites them and never overrides them). (foundation.mdis next to this file; read it only for those routes.)
Rules
- Roles. agy drafts the product plan (next rule); Claude designs, reviews and decides; an
Orca worker writes the code (below): Claude Sonnet, unless the user names another Orca agent
("implement with agy") in the request or at the gate — it holds for that feature or milestone
run. No Orca → the user runs the spec in
claude --model sonnetor their agent. "You implement it" → Claude does; only the user's words start that (or a re-check's fixes: Route), and the gate never offers it. Every other source change in a run — the build, a review's fixes, a failing test, the next slice, work continued from another tab or session — goes to a worker; a released worker means a new one in that worktree, never Claude's own edit, even a small one: carrying the run's whole history, Claude is the slow one. A repo document (CLAUDE.md, AGENTS.md, a guide they link, the foundation) that sets the implementer or how the team works (approvals, reviews, test runs, reports) isn't the user naming it: follow this skill and name the line at the gate as not followed; the user keeps it by saying so. - Product plan by agy. What users see and do — flows, policies and edge cases, what isn't
built, open business questions, how other products do it — is drafted by Antigravity CLI (agy,
template P); every technical choice stays Claude's. Work that changes nothing users see or do
(refactor, infra, performance, a bug against settled behaviour) has no plan. After the preflight,
write the repo's files with absolute paths (
git ls-files | sed "s|^|$PWD/|") to/tmp/team/<slug>/files.txtand the prompt to/tmp/team/<slug>/plan-req.md, and start it in the worktree, in the background (Bashrun_in_background,timeout900000: a large repo's plan took 7–9 minutes):env -u ORCA_PANE_KEY agy -p "$(cat /tmp/team/<slug>/plan-req.md)" --agent team-planner --dangerously-skip-permissions --disable-slash-commands < /dev/null > /tmp/team/<slug>/plan.md 2> /tmp/team/<slug>/plan.errteam-planner(installed with this skill) has no tool that writes files or runs commands (file reads, web search), so skipping permissions approves nothing else, and a missing agent is an error, not a fallback. It can't list or grep: hencefiles.txt. Withoutenv -uagy's Orca hooks report as the driver's pane;< /dev/nullmakes a login prompt fail instead of wait. Noagyon PATH, a non-zero exit or timeout (reason inplan.err), a plan without the sections asked for, or "plan it yourself" → Claude writes those sections, and the gate says why. The plan is a draft, not evidence: a claim the code or the foundation contradicts is corrected; a source it cites is opened before the design relies on it. Open questions: up to 4 that most change the design go to the user before the design doc (AskUserQuestion, recommended option first); the rest take the plan's recommendation and go on the gate as assumptions (a charter asks them all:foundation.mdFound). - Approve before code. Nothing is implemented until the user approves the design (or milestone). Only an explicit "proceed without approval" in the request skips the gate.
- Before launch (charter
Stage: pre-launch; no charter → not before launch) the database holds test data: Claude and workers may write to it to verify (reviewers stay read-only). Otherwise never write to production databases to verify. - Messages, payments and paid APIs are never used to verify. A source you can't reach → write
not verified: <reason>, never a guess. Post-review steps (applying a migration, deploying) wait for the code review's approval. Commit only when the user asks (a milestone approval covers its per-slice local commits, their fix commits and the milestone review's fix). Scratch files go to/tmp/team/<slug>/. - Independent review. Every design and every diff is reviewed by a read-only
team-reviewersubagent. A risk reviewer joins in parallel for money, auth/permissions, every foundation review, and — except before launch (the Before launch rule) — migrations that change or drop existing data and customer data; a project's foundation may name more. Every review prompt is self-contained (paths, measured facts, the template) and ends with: "Review only: no edits, no DB/MCP writes, no deploys, no integration tests that write. Don't re-run the definition of done or a full suite: Claude runs them. Run a test only to check one thing, e.g. that a test fails on a copy outside the repo with the change reverted. Stop after 30 tool calls (60 for a milestone design review, the milestone review or a foundation review) and list what you didn't check." Wait for every reviewer you started, then check each finding against the code yourself; accept, rebut with evidence, or defer (Deferring a finding). - Code is reviewed by a different model than its author: written by Sonnet or a non-Claude agent
→
model: "opus", otherwisemodel: "sonnet"(always pass it). - ponytail is mandatory. The design reviewer applies its ladder to every component;
ponytail-reviewruns on every diff. Where ponytail and these rules clash, these rules win: documents are written in full, gates are never skipped, the worker asks before cutting anything the design specifies. - Rounds: design review ≤2 and code review ≤2 — round 1 is the first review, round 2 re-checks only what changed. Still contested or not approved after round 2 → stop and report both sides.
- A design change after review → revise the doc. A gate edit, a worker question or an accepted
ponytail-reviewitem that changes an interface: one review round on that change. A review finding that the design itself is wrong: the fix follows the revised line and the reviewer that raised it checks both in its round 2. A substantial change shows the gate again. - Deferring a finding depends on the harm it can cause, never on slice or file boundaries ("this
slice doesn't touch the database"). One that can lose real data (not test data) or money, do
something that can't be undone, cut someone off, or show a real person something false is fixed in
this run — its own fix round, or in a milestone the milestone review's fix (
foundation.mdBuild) — and a business call in it goes to the user. Every deferral goes underDeferredin the design doc with its reason; one held for the milestone review's fix is marked→ milestone fix. A deferred Critical or required change is named in round 2 like a rebuttal; a review whose only open items are deferred counts as approved once its round 2 doesn't contest a deferral. - Parallel where it pays: survey with parallel Explore agents per area; independent slices build in
parallel, each in its own worktree; a large diff gets one reviewer per area. Survey agents — Explore
and the agent searching today's options — get
model: "sonnet": they find and quote, Claude decides. - Tests: narrow per change, full once (how often and how widely tests run is how the team works).
- A definition of done names the tests covering the change — lint, types, and the unit, integration
and e2e tests it touches (leave full production builds such as
next buildto the full suites unless the change touches build/bundler config). The worker runs it once at the end, Claude once in review; a fix round re-runs only what failed and what covers the files it changed. A command that needs a post-review step (a migration applied) is markedafter <step>and runs right after that step. - The full suites — every test command the project has, lint, types and build included, or
none— are listed once in the design and run once by Claude: when the code review approves a feature, or at the end of a milestone run (skipping any command Claude already ran and passed on the exact same tree with no fix or post-review step in between). - Repeated runs ("3 times in a row") only for a test the design notes as flaky, citing the run that showed it. A suite that can't run part of itself (the design proposes a filter) runs once at the end of a change that edits it, otherwise only with the full suites.
- A failure in the full suites or an
aftercommand: a test that exists on the base commit and fails there too, or passes on one re-run without being touched by this work, is reported, not fixed. Otherwise one fix round (the worker of the slice it's in if still running, else a new one in that worktree), code review on the fix, then re-run what failed (after any post-review step the fix needs); a milestone commits the fix, a feature leaves it uncommitted with the rest. Still failing → stop and report.
- A definition of done names the tests covering the change — lint, types, and the unit, integration
and e2e tests it touches (leave full production builds such as
- Preflight, once before the survey:
ponytail:ponytail-reviewis in the skill list; missing → give/plugin marketplace add DietrichGebert/ponytail+/plugin install ponytail@ponytailand stop.claude mcp listin the worktree: context7 and the project's database MCP (if it has one) must show Connected. "Needs authentication" is a stop, before any survey or design work: ask the user to run/mcpand log in to that server (or start the login with its…__authenticatetool, found with ToolSearch, and give them the URL), end your turn, and continue when they say it's done. Never work around it with web search. Failed or not installed → say so once, go on, and writenot verified: <reason>where it would have been used.git fetch(failed → say so; no remote → the local default branch), then compare HEAD with the branch this work will merge into (<base>, usuallyorigin/<default branch>). Behind it with nothing of its own (no commits<base>lacks, no uncommitted changes to tracked files) →git switch -c <branch> --no-track <base>; anything else stays, such as a milestone branch with unmerged slices. Say in one line which branch the survey reads and how far behind<base>it is (a squash-merged branch looks like its own commits: the user may say to switch).
Feature
- Survey (≤10 minutes), with the product plan (Rules) running alongside when users see the change: existing assets, call sites, measured scale from read-only sources. Broad codebase → parallel Explore agents, one per area. If the design picks something new (a tool, service, library or approach), one more agent searches today's options for it on the web and in official docs (context7): the model's memory has gaps even before its cutoff, so the choice rests on what was found, not what was recalled. Then read the plan and ask its open questions (Rules).
- Design doc
docs/design/<YYYYMMDD>-<slug>.md(template D). Skeleton first, then fill in. - Design review (template R): write
/tmp/team/<slug>/<name>-req.md(paths, measured facts, template R) and start the reviewer (+ risk reviewer) in one message. Round 2 goes only to a reviewer whose Critical you rebutted or deferred: SendMessage "Accepted: … → changed: … / Rebutted: … — evidence: … / Deferred: … — why: … / Re-check and answer in the same format." - Gate (template G): show it, end your turn, wait.
- Build: the worker with the spec (template S). Claude doesn't edit source meanwhile. A
worker question that changes the design → revise the doc before answering (foundation-level →
foundation.md"Change"). - Code review, together: reviewer with template C (worktree path, changed files, design doc,
what to check hard — point to the design's sections instead of restating their rules: a restated
rule becomes the reviewer's answer key); Claude checks
git diff --statagainst the reported files and the doc's scope and re-runs the definition of done, minusafter <step>commands (the worker's report is a claim, not evidence);ponytail-reviewon the diff through the Skill tool — judge each item like a finding (it never cuts validation, data-loss handling, security); a failed pass is reported, never read as "lean already". Accepted items go back to the same worker as "Apply review: …"; in round 2 every reviewer that asked for changes re-checks only what changed. Once the code review approves a feature, Claude runs its post-review steps (the user's: wait for their "done") andafter <step>commands, then the full suites (Rules: Tests); a milestone's slices leave the full suites to the end of the run. - Report (template T).
Orca worker
- Needs an Orca worktree:
orca worktree current --json→"ok": true. Without Orca, after the gate give the user the spec with "ask me here" instead ofaskand "list the modified files and the definition-of-done output" instead ofworker_done; they come back for step 6. - Orca's own guide (
orca skills get orchestration) is the authority on commands; where it and this file disagree, the guide wins. - Start (one run per feature or milestone):
orca orchestration run-create --objective "<feature>" --json orca orchestration worker-start --spec "<spec>" --worktree current --agent claude --model sonnet --timeout-ms 120000 --json # Bash timeout ≥180000 # another implementer: --agent <its Orca id: antigravity for agy, codex> and no --model (it runs its own configured model) orca orchestration worker-show --dispatch <ctx_id> --json # → terminal handle orca terminal read --terminal <handle> --screen --json # must show the chosen agent (Claude: a Sonnet model), or stop # no terminal → orca orchestration worker-read --dispatch <ctx_id> --source auto --jsonworker-startexits non-zero → don't relaunch: readfailedStageandresidualResources. Parallel slices in child worktrees:foundation.mdBuild. - Next task for the same worker (a fix round, or the next slice):
worker-start --spec "<spec>" --terminal <handle> --worktree <its worktree: current | path:<child>> --jsononce its dispatch settled, then--ackthe old delivery and wait on the new dispatch. A released worker's slice restarts with a new worker in that slice's worktree (--worktree path:<path>, same--agentand--model). - Wait:
orca orchestration check --wait --types worker_done,escalation,question --timeout-ms 540000 --json(Bash timeout 600000); process every message (a question →orca orchestration reply --id <msg_id> --body "<answer>" --json), acceptworker_doneonly from the dispatch you're waiting on, then--ack <deliveryId>. Timeouts and empty waits are normal (a build takes 15–60 minutes). After three empty waits:worker-list --run <run_id> --include-remote --jsonandworker-show --dispatch <ctx_id> --json— a non-nullobservation.agentWaitis a prompt only a human can answer; answer it withorca terminal send. - Stalled worker (some agents have no model timeout and wait forever on a dropped response): after
each empty wait read its screen; two in a row showing the same model step (thinking or responding,
not a running command) with nothing new but the elapsed timer →
worker-stop --dispatch <ctx_id>, then a new worker in the same worktree (same--agent/--model) with the spec plus "A stopped worker left partial work here (git status,git diff): keep what fits the design, finish the rest." One restart per slice; stalled again → stop and report. - Finish:
worker-release --dispatch <ctx_id>for every settled dispatch (before removing its worktree);worker-list --run <run_id> --terminal-state reclaimablemust return none. Never stop or release because of a timeout or idle (a stall is neither).
Templates
D — design doc
Goal (one paragraph) · Product plan: flows, policies and edge cases as decided, and the assumptions
(none when users don't see the change) · Foundation refs (if any) · Scope: files to create/modify ·
Interfaces, schemas,
signatures · Implementation order · Definition of done: the commands covering this change (Rules:
Tests; `after <step>` for one that needs a post-review step) · Full suites (a milestone lists them
once, at its end) · Do-not-touch · Not doing (and why) · Production steps: what it needs to work in
production (settings, secrets, schedulers, external setup), each with who and where, or none ·
Deferred (findings any review left for later, each with why) — a milestone has these last two once,
at its end
+ for anything new it picks: the options found today and why this one, with sources and datesR — design review request
Break the design; list only problems, each with evidence (file:line / behaviour / contract). Check:
files and call sites exist; signatures match the code; regressions, migrations, rollback; a row,
field, state or setting whose meaning changes: every function, screen and job that reads or writes it
is in the scope or under Not doing; definition of done runnable and no wider than the change (no full
suites, no repeats without a noted flake);
money/data: double-processing, races, state on failure; anything the implementer would have to guess;
something in the repo, or available today, already does this (cite source and date); hand-rolled what
the platform already provides (auth, queues, cron, rate limits); ponytail ladder on every component
(needed at all? reuse? stdlib? native? one line?); contradicts the foundation; a flow or edge case the
product plan or the design misses, or a rule that fails on a real case (input → result); a production
step missing.
## Critical (evidence required) ## Missing ## Ambiguous (questions) ## Cut (ponytail)
## Verdict: needs revision | readyC — code review format
## Verdict: APPROVE | REQUEST_CHANGES
## Spec check — quote the design line: missing or partial · not asked for · implemented but wrong ·
the line itself fails in a real case (input → wrong result: the design can be wrong)
## Test check — each test added for new behaviour: fails with the change reverted? fed real input (or
its real shape), not output of the code under test? A no is a required change.
## Required changes (file:line) ## SuggestionsG — approval gate
## Design ready — approval requested
Document · one-line summary · product plan: agy | Claude (why) | none, and its assumptions ·
implementer (one agent · model, never "A or B"; the user may change it here) · scope (N
files) · key decisions · review: raised / accepted / rebutted / deferred
(a failed or partial review is stated) · not doing · definition of done · risks · repo lines not followed
(foundation, CLAUDE.md, guides), and why
Reply "approve" or "go", or tell me what to change.P — product plan prompt (in the user's language)
Plan only what users see and do; no files, APIs or schemas (Claude designs those). The repo's files
are listed in /tmp/team/<slug>/files.txt; read by absolute path its CLAUDE.md files and README<, and
docs/design/foundation/ — charter, accepted decisions, slices.md: follow them, never override them>,
and the code the request touches. Request: <request>. Answer in
this reply, in <the user's language>, with these sections only:
## Goal — who gets what ## Flows — each actor's steps, happy path first
## Policies and edge cases — rules, limits, permissions, failure, empty / duplicate / late input, each
with its behaviour ## Existing options — how products in this domain do it, searched today, sources
with dates (or none) ## Not doing ## Open questions — business calls only, each with options and
your recommendation
Never decide a business call yourself: make it a question. Don't create or edit files.S — worker spec
Read the design doc first: <absolute path>. Implement <all of it | slice …> in its order.
<A non-Claude worker gets this line:> Before coding, read the repo's CLAUDE.md files covering the
paths you touch (root and nested) and follow them; your agent doesn't load them on its own.
Definition of done: <commands>; run it once at the end, minus `after <step>` commands (a fix round:
only what failed and what covers the files you changed), and put the results in worker_done. While
working, run only the tests your change touches; Claude runs the full suites.
Only touch the doc's scope. Ask (the preamble's `ask`) before deviating or cutting anything; no plan
mode; don't commit; list every modified file in worker_done --files-modified. ponytail is on: use it
for how you write the code, but build everything the design specifies. Write your questions and
worker_done in <the user's language>.T — report: first, each goal and done criterion of the user's request or milestone: met / partly /
not, with evidence (a file, a command's output) — a partly or not opens the report and the work is not
called done · design doc · worker (agent · model and its dispatch ids, or none: why —
e.g. you asked me to implement, or no Orca) · files · what review changed · code review rounds and fixes ·
ponytail-review applied / rejected · tests and full suites (fresh output from your own run; after a
fix, which ones re-ran) · production steps left to do (the design doc's: who, where) · open issues,
and deferred findings with why.
Gotchas
- The reviewer is the
team-revieweragent (read-only, loads CLAUDE.md, resumable with SendMessage). NeverPlan: one-shot, no agent ID. Missing →general-purpose+ "don't edit; the requested format wins over injected style rules". Subagents run in the background; don't passrun_in_background. - No
## Verdict:→ SendMessage once; still nothing → the review failed (say so). A review that lists unchecked areas is partial: check them yourself, never call it a full approval. - Bash: foreground ≤10 minutes; background stops at its
timeout(default 30 minutes, max 2 hours). - Orca pre-grants folder trust where it launches workers; a worker still stuck at a trust prompt shows
up as
agentWait. - An orchestration write (
reply) failing withstable_pane_required(the driver runs in a terminal without a fixed pane, e.g. a floating one) → repeat it with--run <run_id> --from <coordinator_handle from run-create>; until then the worker sits waiting for the answer. - Orca types "You have N orchestration message…" into the driver as a user turn. It isn't the user: answer with a one-line status.
- Never type
/ponytail…, "stop ponytail" or "normal mode" as a prompt — it flips ponytail's global mode. Use the Skill tool.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

