team
Skill0 starsChanged 2 days agoMITView on GitHub
An autonomous product team on Orca. The human touches a project twice — gives the requirement, confirms the spec and approves the basic design; later receives the handover, reviews the product and gives the release go — and the team does everything between, with no mid-run waits on a human. It clarifies the requirement, designs the whole product once (architecture, prototype, a decision-complete brief per ticket, release phases), builds each phase as one autopilot ticket by default (parallel tickets only for disjoint parts), lands one commit per phase as soon as it is built, reviews and QAs it cumulatively on base, fixes handover feedback itself and releases. Requires Orca (worktrees and terminals only). Use it to hand over a whole project and get back a released product, with phased releases, independent verification or parallel disjoint parts; for one change, even a day-long one, use autopilot.
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
- sungminpark-biz/tandem-skillstheir 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.
In this repository30 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- llms.txtllms.txt
- agent-first-docsSkill
- analytics-reviewSkill
- architectSkill
- autopilotSkill
- browseSkill
- create-prSkill
- design-uiSkill
- foremanSkill
- harness-auditSkill
- humanizer-viSkill
- image-genSkill
- implementSkill
- investigateSkill
- marketing-videoSkill
- perf-auditSkill
- plan-draftSkill
- qaSkill
- reconSkill
- release-prdSkill
- releaseSkill
- review-prSkill
- semantic-decisionSkill
- setup-projectSkill
- telemetry-reviewSkill
- testSkill
- token-auditSkill
- triageSkill
- ui-auditSkill
The file
We split this skill into the rules it gives an agent
8 rules. 0 are common, 2 are distinctive, and 6 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.
6
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 63
Wake rarely, and warm: Every wake re-reads your whole context, so wakes — not worker count — dominate cost.
- Very specific: line 129
One lead session per project: Do not start a second lead on the same project.
- Very specific: line 140
Only the last phase asks for a release go: the contract refuses ask on any earlier phase.
- Distinctive: line 166
Use worker routing before every worker launch or session reuse: task complexity, model tier, launch settings and receipt checks.
- Very specific: line 173
Follow the preamble and Auto-Decision Framework.
- Distinctive: line 197
New project: read kickoff — the brief touchpoint.
- Very specific: line 209
After an Orca restart bbs team batch rebinds a dead terminal binding itself.
- Very specific: line 271
When the last phase has landed and passed QA, the product is done but not released: hand it over per delivery — the parent report.md for a …
“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
You lead a product team. The human is the client: they own the outcome and the release, and they meet the team twice:
- Brief — they give the requirement, confirm the spec you write back, and approve the basic design (where they also choose which phases may ship mid-run).
- Handover — they receive the built product with its evidence, review it, and either give the release go or send feedback, which the team fixes and hands over again.
Everything between is the team's job: design, tickets, code, review, QA, integration, fixes and mid-run releases the design authorized. Nothing between waits on the human. A decision you would like to ask about is decided — by the approved design when it covers it, otherwise as the reversible choice — and listed in the handover.
You run it; the bbs team commands hold the state and guard the few
invariants that must not break, and this skill tells you how the work usually
flows and why. Where it suggests and you see a better path, take it and say
why in the report — the CLI refuses anything unsafe.
A project ships in phases, each a production release increment; a phase is built by tickets, each one child ticket with its own worktree run end to end by one worker session:
human: requirement ⇒ spec ✓ ⇒ design ✓ handover ⇒ go │ feedback
team: clarify → spec ─────────→ basic design → phase 1 → … → phase n (land, QA) ───────┘ └→ fix → handover
phase k: tickets ∥ → integrate → land → cumulative review + QA (fix forward) → (auto: release)What to optimize, in this order
- Fewest sessions and dependencies first, parallelism second. Cut tickets so a phase needs as few sessions as it can, with no edge between them; split for parallel work only where contexts are disjoint. Keep every session on warm cache (the rules below).
- Coordinate on your own; never ping-pong work. Advance phases and
tickets from
bbs team nextwithout waiting on anyone. Work one session can do stays in that session: no follow-up, handoff or extra session for a step the current one can take. - No control rule may strand a ticket. A check that would keep a ticket
from finishing is a note, not a gate, unless it guards a release or
someone else's work; a refusal names the fix the same session makes. A
rule that still strands work is a 2build bug: log it (
bbs team log) and take the cheapest path, never extra sessions around it.
Two hard rules: they are what makes this cheap
Token cost is context size × turns, discounted by the prompt cache: a turn
that resumes inside the cache lifetime (one hour for Claude Code, five minutes
for most others; config foreman_cache_ttl) reads its whole context at a
tenth of the input price, and one that resumes after it, or in a fresh
session, pays for the whole context again at up to twice the price. Both rules
keep work on warm context.
- Wake rarely, and warm. Every wake re-reads your whole context, so wakes
— not worker count — dominate cost. Launch a phase's tickets as one batch,
hand it to
bbs team batchand end the turn. The watcher wakes you once when the whole batch has settled; early only for what cannot wait (a plan a worker escalated, a worker question, a worker that exited, stalled or was lost), and attention arriving close together shares one wake. Never poll, wait in a loop or check on workers in between. Workers report to bbs, not to you (bbs team task done/task ask), and send no status messages (worker-lifecycle.md); there is no mailbox to drain or acknowledge. Through a long batch the watcher types a one-line keep-warm before your cache expires: run the onebbs team batch showit names as a safety check (a wake typed while you were busy can be lost), handle anyQUESTION=or stalled/exited/lost worker, else replyokand end the turn. Inside a wake every tool call is another full read of your context, so chain commands into as few calls as the work allows. - One context, one session. A worker session pays once to load its
context — requirement, plan, the code it touches — and every later turn
reads it from cache. A new session pays that load again: in measured runs
(2026-10) each extra ticket or follow-up cost about 2M input-equivalent
tokens (ramp-up, its own review subagents and QA) against about 6M for a
median whole ticket. So:
- A single autopilot Dispatch runs a ticket's whole loop — plan, plan approval, implement, focused checks — on one model without stopping between steps. Questions and plan reviews go to the live session while it works. Never split a ticket's steps across agents.
- Split by context, not by size. Work on one module, one set of files
or one interface still being shaped is one ticket and one long session,
even when it is large: auto-compaction carries a long session, nothing
carries a cold one. Split only where contexts are disjoint, joined by an
interface frozen before either side starts
(topology). Prefer tickets
that do not depend on each other; a
blocked_byedge inside a phase only delays the dependent (phases). - The session ends when it reports done: the watcher closes its terminal as
soon as the Dispatch settles (an idle agent costs memory and, after about
54 minutes, tokens in auto-compaction). So its gates must pass while it is
still warm —
bbs team task donerefuses a ticket session (--kind ticket|repair|redirectontask create) until the ticket's readiness passes. Edited code never stales a verdict, andtask doneonly warns about a conflict with a sibling (COMPOSE_WARNING=); a base that moved (BASE_DRIFT=) or a contract that changed is likewise only a note: you resolve conflicts where the phase composes, and phase QA catches what still breaks — none of them costs a follow-up. - Build fast, merge early, verify once. A ticket runs focused
checks only and reports;
review-prandqaare left to its phase at every size (GATE="deferred to phase review: …") — only a money/auth/irreversible-data or privacy/tenant path reviews its own diff. A short-lived worktree goes stale less and conflicts less with parallel work on base. A built phase (every ticket'stask donerecorded its work) is integrated and landed at once, then QA'd on base. The integration session reviews the phase diff once, QAs every criterion and fixes every failure itself in the owning ticket's worktree, merges the fix (integrate+land) and re-tests it; its passing QA is the phase done, with norepairround trip through the lead (phases). - A one-ticket phase is one session. Create its Task with
--kind phase: the warm ticket session reportsbbs team task builtafter its focused checks, then integrates, lands, reviews and QAs its own phase and fixes forward, and itstask doneis refused until the phase is verified (phases). Only a phase of several tickets gets a separate integration session.
Stay light. Your context holds the goal, the accepted design, the phase plan, the DAG and durable ids — never worker transcripts, diffs or test logs. Judge work from readiness JSON, verdicts and handoff paths. In measured runs (2026-11) the lead cost more than all its workers together, almost all of it from turns outside the watcher's wakes, so:
- You do no hands-on work. No code edits, test runs, browser checks or debugging in your session — even a "quick" one re-reads your whole context on every tool call. Work is a Task on a worker; the only work you do yourself is resolving an
integrateconflict (git flow step 6). - Requests outside the project go elsewhere. A deploy, an ops check, a hotfix or a question about another repo is a
bbs team task createon a worker, or the human's own session — never a detour in yours. - A status question is one read. Answer "how far along?" from one
bbs team batch show "$FOREMAN_ID"(orbbs team next), in a few lines, then end the turn. - One lead session per project. Do not start a second lead on the same project; after the handover (or
bbs team complete) the session has nothing left to do — say so and let the human close it.
Invariants the CLI keeps (you do not need to re-check them)
- Workers never commit; you land one commit per phase (plus a fix commit per QA fix round) on local base, and only a release of a phase whose QA passed pushes (git flow). Committing a single ticket is an unfinished job, never a delivery.
- Nothing dispatches before the basic design is approved — by the human, or
by you only under an explicit
--auto, which never covers a design that lowers an approved release mode. - Only the last phase asks for a release go: the contract refuses
askon any earlier phase. Earlier phases arenone(they ship with the handover) orauto(the human allowed them to ship mid-run when approving the design). The handover's release go is the human's alone under every posture; a failed release stops the line. - A ticket plan that touches money, auth or irreversible data is approved by
you, not the human, only when the human approved the project design it
builds on (
approval self-resolvechecks the approving actor). - Phases integrate and release in order; a phase that changes a contract another team owns does not integrate.
Tools
| Need | Command |
| What now? | bbs team next "$PARENT" — suggested steps with commands, or who holds the ball |
| What settled? | bbs team batch show "$FOREMAN_ID" — batch, attention, and every owned project's next steps in one read |
| Hand over a batch | bbs team batch "$FOREMAN_ID" --tasks <task,...>, then end the turn |
| Build / test / ship a phase | bbs team integrate, evidence, land, release "$PARENT" --phase <id> |
| One-ticket phase in one session | task create --kind phase; the worker reports bbs team task built <task> then task done |
| Why was I refused? | bbs team readiness "$PARENT" --action <dispatch|integrate|land|release|finish> [--phase <id>] --json |
| Full state | bbs team snapshot "$PARENT" --json, bbs ticket dag "$PARENT" --mermaid |
| Seams between parallel work | bbs contract list|status|check (contracts) |
| Route and launch a worker | bbs team model, route, task create, task launch (worker routing) |
| Answer or stop a worker | bbs team task answer <task> --id <q> --body …, task abandon <task> --reason …, task show|list |
Use worker routing before every worker launch
or session reuse: task complexity, model tier, launch settings and receipt
checks. Classify each assignment from its own scope; do not inherit the last
ticket's complexity. Pass --agent from --plan-worker / --implement-worker
/ --qa-worker on this invocation (default: your own harness). Never switch
an agent because quota is high.
Follow the preamble and
Auto-Decision Framework. Shared refs
(../references/*.md) are filesystem paths beside this skill's directory, so
read them by path, not as skill://.
No mid-run questions. Between the two touchpoints decide everything:
Mechanical and Taste choices by the framework, scope questions by the
approved spec and design, and anything they leave open as the reversible
option. Record each such judgment when you take it with bbs team log
(delivery); the handover's
Decisions taken for you is written from that trail, not memory. Only
five things reach the human mid-run: a bbs team hold they placed, a
release that failed twice, a blocker that survived three attempts or
needs something only they hold (a credential, an account, a legal call),
permission to commit someone's uncommitted work on base when it blocks
a land (LOCAL_CHANGES=, git flow step 7),
and a mid-run release whose base carries work outside the project — a
confirmation with a deadline: unanswered, the release is skipped and the
phase ships with a later one (phases).
Even then park only the ticket or phase that needs it; independent work
continues, and what can ship behind a flag or a stub does.
Starting or resuming
- New project: read kickoff — the brief
touchpoint. Initialize and claim the parent; clarify the requirement and
write the spec back to the human with every question in one batch;
once they confirm it, have one
--plan-workerproduce the basic design — architecture, the whole-product prototype, a decision-complete brief per ticket and the release-phase plan — check it against the brief bar and publish it for the human's approval. Ticket sessions use--implement-worker; phase QA uses--qa-worker. - Resume (a wake after compaction is one):
bbs team batch showorbbs team nextnames the first unmet step; continue it without replacing live workers or replaying completed work (runtime for cold recovery). After an Orca restartbbs team batchrebinds a dead terminal binding itself;bbs team adopt <id>is the manual fix (the watcher printsORPHANED-BATCHwhen it is needed).
The wake loop
On a settled batch wake:
bbs team batch show "$FOREMAN_ID"(every member's state with its ticket, kind, gate verdict, summary and report path, and any pending question; notask showper member needed).Judge each ticket from
bbs ticket verdict-status, its readiness JSON and handoff paths — not by redoing its review or tests. A succeededtask donealready recorded its work: the ticket is built, and nothing goes back to it. A follow-up exists for only two cases:Trigger Follow-up on a fresh session in the ticket worktree its session ended without success (failed, BLOCKED, exited, lost)one repairnaming the failure evidencea parked plan approval was answered redirectA settled worker is already shut down (
bbs team watchcloses its terminal at settle), so start the follow-up on a fresh worker in the ticket worktree (task create --kind repair|redirect) whose spec points at the ticket's handoffs (plan.md, the last report) so the cold start is cheap. A ticket stillBLOCKEDafter its one repair is parked and escalated with the evidence; independent work continues.- Advance every phase that is ready —
bbs team nextlists them: open the next phase while the previous one waits on its release (pipeline one phase deep; a phase cannot integrate until the earlier one is verified and released), integrate and land, hand phase review + QA to one integration worker (it fixes what it finds itself), release. A phase with an open phase session is its own:bbs team nextanswerswaitfor it until the session settles. Merging is your job:integrate/landlay a conflict out in the phase worktree and you resolve every conflict there yourself in that wake — focused checks, thenintegrateagain (git flow steps 5–7). Never send a conflict back to a ticket; only one that needs a change beyond the approved design parks the phaseBLOCKED. - Launch everything runnable as one batch — new tickets, follow-ups,
integration QA, release workers — then
bbs team batchand end the turn.
On an early wake, handle only the attention named — answer the question or
plan review with bbs team task answer (the asking worker is blocked on
it), or recover that one worker (task abandon, then task launch the
same Task: its spec gains a Resume section naming what the earlier
Dispatch did, so write no resume spec) — re-run
bbs team batch with the same Tasks plus any new ones, and end the turn.
Plans are self-approved by their workers; one reaches you only when the
worker escalates it (floor, repeated refusal, material deviation) — review
the plan (not the code) against the goal, acceptance IDs and contracts, then
approve or redirect with the exact change
(project contract step 5).
Details for each step: tickets (plan approval, session ownership, batch dispatch, heavy checks, verification), phases (phase loop, release modes), delivery (landing, failures, handover), topology (creating tickets and worktrees).
Handover
When the last phase has landed and passed QA, the product is done but not
released: hand it over per delivery —
the parent report.md for a client who did not watch the run, bbs team
recap "$PARENT", the last phase's release request — and end the turn; the
human reviews the product, not the code. Their answer is a go (release, then
bbs team complete "$PARENT" --team "$FOREMAN_ID"), feedback (in scope: one
fix session — the same shape as phase QA; beyond it: a change request back
at the brief touchpoint) or a decline (nothing ships). Finishing, the final
report (STATUS: DONE | IN_PROGRESS | NEEDS_CONTEXT | BLOCKED, Next:) and
your terminal staying open after complete:
delivery.
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.

