An entire team. Wherever your AI lives.

_{Your AI tool just got 100× more capable.}
Free. MIT. 90 seconds.

Install What it does Demos Built on Architecture

One coder typing prompts? That was last year.

Coco turns your AI tool into a team. Multiple agents. Working in parallel.

State that survives. Verification before "done." Free. MIT. Yours.

git clone https://github.com/rkz91/coco.git && cd coco && bash install.sh

_{90 seconds. That's the whole onboarding.}

What you get

_{USER-INVOKABLE}

93

_{things you can invoke right after install}

59

_Skills

34

_Commands

10

_Agents
_{_(spawned)}

3

_Systems

4

_Adapters

15

_Rules

$0

_Forever

_{Plus opt-in bundles: +68 GSD skills · +24 GSD agents · +6 Brain skills · Team multi-agent pipelines}

Three pillars

A team.
Not a single coder.

/team:ship runs 7 stages with role-appropriate agents at each layer. Researcher → Architect → Planner → Reviewer → Fixer → 4× Builders → Verifier. You approve once. The team handles the rest.

State that
survives anything.

Most AI sessions die on /clear. Coco doesn't. 68 orchestration skills with disk-backed phase state. Atomic commits per step. Roll back any decision. Resume from any checkpoint.

One install.
Any AI tool.

Pure markdown + frontmatter. Adapters wire into Claude Code, Cursor, Codex, or any AGENTS.md tool. Switch tools in 6 months — your skills follow.

YOLO mode

/coco yolo

Skip the approval gates. Let Coco run.

_{Activates autonomous mode. Multi-stage pipelines complete end-to-end without asking permission between phases. Combine with /gsd-autonomous and --systems gsd to run an entire roadmap unattended. Toggle off with /coco careful or /coco normal.}

_{Use it when: You trust the plan and want to walk away. Long debug runs. Overnight builds. Multi-phase migrations. Atomic commits give you a paper trail and full reversibility — even with autonomy on.}

Before Coco vs After Coco

You ask	Plain Claude Code / Cursor / Codex / Antigravity does	Coco-powered AI does
"Build a habit tracker"	Generates one component, gets confused on routing, you guide it for 4 hours	Researches the space, picks a stack, plans 5 phases, runs 4 build agents in parallel, verifies, ships — you watch
"Audit this code"	"Looks fine!"	7-category audit: TDZ errors, import mismatches, broken refs, dead code, mock leakage, CSS regressions, React anti-patterns
"Debug this"	"Have you tried turning it off and on?"	Reproduces → isolates → diagnoses root → fixes → verifies, with checkpoints at every step
"Clone this design"	Generic Tailwind blob	Pixel-perfect single-file HTML with all design tokens extracted, opens in any browser
"Write a spec"	200 words, mostly fluff	13-section PRD with user stories, success metrics, risks, open questions
Context resets	Start over from scratch	Resume exactly where you left off — phases, decisions, tasks all persisted

See it run

Reverse-engineer any site

/clone-website https://stripe.com

Single-file HTML. All design tokens extracted (colors, typography, spacing, shadows, radii). No build system. Opens in any browser.

Catch AI-introduced bugs

/code-verification

7-category audit on freshly-generated code. Saves 30+ minutes of debugging per session.

Debug autonomously

/systematic-debugging

Reproduce → isolate → diagnose → fix. Checkpoints at each step. Resume after context reset. Walk away. Come back to a fixed bug.

Generate a PRD in 30 seconds

/prd-generator

13 sections: problem, users, requirements, stories, success metrics, risks, timeline, open questions.

Design like Apple, not generic AI

/ui-ux-pro-max

50 styles. 21 palettes. 50 font pairings. 20 chart types. Opinionated picks per domain.

Build a personal AI brain

bash install.sh --systems brain
/brain-init && /brain-update

Local SQLite. Auto-extracts entities, decisions, threads. Wikipedia articles per entity. Yours forever.

Power features

CoCo router

/coco

Conversational dashboard wrapping every skill, command, and system. Routes "what's blocking?", "draft a status update", "tell me about Stripe" to the right artifact automatically. Time-aware. Remembers your last session.

Multimodal memory

/media-memory

Ingest, embed, and search across images, video, audio, and documents. Gemini Embedding 2 + ChromaDB. Auto-logs anything you generate or share. Auto-queries when you reference past media.

Recurring + scheduled agents

/schedule run /audit-prs every Monday
/loop 5m /watch-deploy

Cron-style remote routines plus interval loops. Send an agent to triage your queue, watch a deploy, follow up on a flag — without you sitting there.

Email triage suite

/email:summary
/email:today
/email:reply <subject>
/email:search <keywords>
/email:thread <subject>

Daily summary, today's mail, drafted replies, threading, search, save-to-folder. Reads your real Outlook.

Workstreams (parallel branches)

/gsd-workstreams create feature-x
/gsd-workstreams switch feature-y

Run multiple parallel branches of work in the same project. Each workstream tracks its own state, plan, and progress.

Workspaces (isolated copies)

/gsd-new-workspace

Create a sandboxed copy of the repo with independent .planning/. Try a refactor without polluting your main workspace.

Hookify (prevent bad behavior)

/hookify

Create hooks that block unwanted AI behavior — based on conversation analysis or explicit rules. Stops your AI from running git push --force at 3am.

AGENTS.md export

bash adapters/codex/install.sh

Compiles every skill, command, agent, and rule into a single AGENTS.md. Drop into any project. Codex, Aider, Continue, Windsurf, Cline pick it up automatically. In Codex this is prompt context, not necessarily a visible slash-command palette.

Forensics (post-mortem)

/gsd-forensics

When a phase fails, analyze git history, artifacts, and state to diagnose what went wrong. Auto-generates a structured forensic report.

Caveman mode

/caveman full

Compress AI output ~75% by speaking like caveman while keeping technical accuracy. Saves tokens. Useful for long sessions.

Multi-agent dispatching

/dispatching-parallel-agents

4 patterns for orchestrating agents: single-wave (independent), multi-wave (sequential), shared-files (handoff via disk), resume-chains (deep iteration). Picks the right one for the task automatically.

Verification gates

/verification-before-completion
/code-verification

Before claiming "done," Coco runs verification: build, lint, imports, references, tests, behavior. Auto-blocks "looks good!" output without proof.

How it works

flowchart LR
  U["You<br/>(slash command, plain English)"] --> AI["Your AI tool"]
  AI --> A["Adapter"]
  A --> S["Coco artifacts<br/>skills · agents · commands · workflows · systems"]
  S -.read at runtime.-> AI
  AI --> Agents["Spawned agents<br/>(parallel waves)"]
  Agents --> AI

_{One source of truth. Adapters handle IDE specifics. Skills run multi-agent waves when needed.}

Architecture deep-dive: docs/architecture.md.

Install

Standard (90 seconds)

git clone https://github.com/rkz91/coco.git
cd coco
bash install.sh

Auto-detects your AI tool.

Via npm (GitHub Packages)

# one-time auth
echo "@rkz91:registry=https://npm.pkg.github.com" >> ~/.npmrc
echo "//npm.pkg.github.com/:_authToken=YOUR_GH_TOKEN" >> ~/.npmrc

# install
npm install -g @rkz91/coco-cli
coco

Token: read:packages scope. Full guide.

With orchestration bundles

bash install.sh --systems gsd,brain,team

+68 GSD skills · +24 GSD agents · +6 brain skills · +Team pipelines.

Update later

# git clone install
cd coco && git pull && bash install.sh

# npm install
npm update -g @rkz91/coco-cli

Adapter override

bash install.sh --adapter claude-code
bash install.sh --adapter cursor
bash install.sh --adapter codex
bash install.sh --adapter generic

Uninstall (clean — symlinks only)

find ~/.claude ~/.cursor -type l \
  -lname "*$(pwd)*" -delete

Compatible AI tools

Tool	Adapter	Status
Claude Code	`claude-code`	stable
Cursor	`cursor`	stable
Codex CLI	`codex`	stable
Aider, Continue, Windsurf, Cline (anything reading AGENTS.md)	`generic`	stable
VS Code (via Continue)	`vscode-continue`	_{v0.2 planned}
Antigravity (Google)	`antigravity`	_{v0.2 planned}

Built on

_{Coco stands on the shoulders of these open-source frameworks. Special thanks to their authors and contributors.}

Project	Author	What it gave Coco
obra/superpowers	Jesse Vincent (@obra)	The 15 foundational skills — `brainstorming`, `systematic-debugging`, `test-driven-development`, `verification-before-completion`, `dispatching-parallel-agents`, and more. The methodology that makes AI agents systematic instead of reactive.
gsd-build/get-shit-done	TÂCHES	The 68-skill GSD project orchestration framework. Phases, atomic commits, parallel agent waves, verification gates, state persistence.
JCodesMore/ai-website-cloner-template	@JCodesMore	The website cloning approach behind `/clone-website`.
Anthropic Skills spec	Anthropic	The Skill format (frontmatter + markdown body) and discovery pattern.
agents.md	community	The vendor-neutral spec that makes Coco's `generic` adapter possible across Aider, Continue, Windsurf, Cline, and Codex.
Anthropic Claude Code	Anthropic	The first-class invocation model for skills, commands, and agents.
Cursor	Cursor team	The rules + skills format for one of Coco's primary adapters.

_{If you build on top of Coco, please credit it the same way.}

Tech specs

Version	0.1.0
License	MIT
Skills	59 (+68 in GSD bundle, +6 in Brain bundle)
Slash commands	34 across 6 namespaces
Agents	10 core + 24 GSD subagents (in bundle) = 34 specialized roles
System bundles	3 (GSD, Brain, Team) — opt-in
Cross-IDE rules	15
Stable adapters	Claude Code, Cursor, Codex, Generic AGENTS.md
Install time	≤ 90 seconds
Runtime cost	$0
Telemetry	None
Accounts required	None
Server-side	None — pure local files

FAQ

Does Coco work with my AI tool?

If your tool is Claude Code, Cursor, Codex, Aider, Continue, Windsurf, Cline, or anything reading AGENTS.md — yes. Run bash install.sh --list to see all adapters.

Is my data private?

Yes. Coco is pure local files. No SaaS, no telemetry, no accounts, no servers. Everything runs on your machine. Your AI tool's privacy policy applies for any data it sends to its own provider — Coco doesn't add to that.

Does it cost anything?

Coco itself is free, MIT-licensed, forever. You only pay for whatever AI tool you use it with (Claude API, OpenAI API, Cursor subscription, etc.). Coco doesn't add cost.

Can I customize a skill?

Yes. Every skill is a markdown file under skills/<name>/SKILL.md. Edit it. Re-run bash install.sh to refresh. Or fork and add your own — see CONTRIBUTING.md.

What if I switch from Claude Code to Cursor next year?

Re-run bash install.sh --adapter cursor. Your skills follow. Coco's whole point is portability.

Will I get conflicts with my existing setup?

No. The Claude Code / Cursor adapters use symlinks; non-symlink files at target paths are skipped. Use --dry-run to preview.

How do I uninstall?

find ~/.claude ~/.cursor -type l -lname "*$(pwd)*" -delete

Removes only symlinks pointing into your Coco clone. Your existing skills stay intact.

Can I use just one part of Coco?

Yes. Skip the system bundles to keep it minimal (just bash install.sh). Or pick: --systems gsd for orchestration, --systems brain for knowledge, --systems team for multi-agent pipelines.

Does Coco replace my IDE's built-in AI?

No. Coco extends your AI tool with a curated library of skills/commands/agents. Your IDE's AI does the actual thinking.

How do I contribute a skill?

See CONTRIBUTING.md. Short version: add skills/<name>/SKILL.md with frontmatter, open a PR. We aim to review within a week.

Is there enterprise support?

Not yet. Coco is community-maintained. For paid support / custom skills development, open a discussion.

Star history

Coco alongside the frameworks it builds on:

_{If Coco saves you time, consider starring the repo. We also encourage starring obra/superpowers and gsd-build/get-shit-done — the frameworks Coco stands on.}

Browse the library

skills/ · commands/ · agents/ · workflows/ · templates/ · rules/ · systems/ · adapters/ · docs/ · examples/

Top-level docs: Architecture · Install matrix · Getting started · Recommended plugins · Troubleshooting · Contributing · Code of Conduct · Security · Changelog

_{If Coco saves you time, star the repo. It's the cheapest way to support the project.}