Does coco auto-invoke its skills?

Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.

Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Development

Plugin

coco

Meet Coco. A superintelligent agent framework powered by an advisory board of 389 world-class minds. Scale your AI assistant into a complete engineering department with 142 skills, 277 commands, and persistent state. Universal compatibility. Local privacy. Free and open source.

FLOW.md

coco-research@coco-research

GitHub

Plugin Signal92/100Strong

maintained99

capable100

documented100

adopted52

Install

$ npx -y skills add coco-research/coco --agent claude-code

Run the curl in your terminal, the rest in Claude Code.

Stats

JavaScript React Next.js Tailwind HTML

+7 tags

CSS Bash Git GitHub Anthropic OpenAI MCP

263

Stars

Forks

Active

Maintenance

JavaScript

Language

1d ago

Last commit

3mo ago

Created

Repo: coco-research/coco

In this plugin

174 skills 41 commands 37 agents

See everything inside

What's inside

Skills

174

/create-ruleCreate Cursor rules for persistent AI guidance. Use when the user wants to create a rule, add coding standards, set up project conventions, configure file-specific patterns, create RULE.md files, or asks about .cursor/rules/ or AGENTS.md./create-skillGuides users through creating effective Agent Skills for Cursor. Use when the user wants to create, write, or author a new skill, or asks about skill structure, best practices, or SKILL.md format./create-subagentCreate custom subagents for specialized AI tasks. Use when the user wants to create a new type of subagent, set up task-specific agents, configure code reviewers, debuggers, or domain-specific assistants with custom prompts./migrate-to-skillsConvert 'Applied intelligently' Cursor rules (.cursor/rules/*.mdc) and slash commands (.cursor/commands/*.md) to Agent Skills format (.cursor/skills/). Use when the user wants to migrate rules or commands to skills, convert .mdc rules to SKILL.md format, or consolidate commands /update-cursor-settingsModify Cursor/VSCode user settings in settings.json. Use when the user wants to change editor settings, preferences, configuration, themes, font size, tab size, format on save, auto save, keybindings, or any settings.json values./agent-lightningTrain and optimize AI agents using Microsoft's Agent Lightning framework with reinforcement learning. Use when setting up agent training, instrumenting agents with tracing, configuring LightningStore, implementing reward functions, or optimizing prompts with RL/APO algorithms.

Show all 174 skills

/ai-marketing-videosCreate AI marketing videos for ads, promos, product launches, and brand content. Models: Veo, Seedance, Wan, FLUX for visuals, Kokoro for voiceover. Types: product demos, testimonials, explainers, social ads, brand videos. Use for: Facebook ads, YouTube ads, product launches,/ai-productExpert in shipping production-grade AI-powered features — LLM integration patterns, RAG architecture, prompt engineering that scales, AI UX that users trust, safety and guardrails, streaming, and cost optimization./api-design-principlesMaster REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards./arb-reviewGenerate an Architecture Review Board (ARB) presentation in Coco Inc's standard 11-slide format. Use when someone asks to "create an ARB deck", "architecture review presentation", "prepare for architecture review board", "ARB slides", or needs to present a product/platform /arch-indexBuild and validate .arch/index.json — a committed map from each architectural component of this repository to the real directories and files that implement it, pinned to a git commit, with every path verified to exist. Also detects structural drift between that index and the /axiom-liquid-glassApple Liquid Glass design system — comprehensive design philosophy, implementation guide, and technical API reference from WWDC 2025. Covers design principles (iOS-native glass hierarchy, restraint over spectacle), implementation patterns (Regular vs Clear variants, SwiftUI /brainstormingYou MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation./browser-automationBrowser automation for AI agents. Two providers — agent-browser (local CLI with Playwright) and agentic-browser (cloud via inference.sh). Both use the same @e ref-based workflow for navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, and /c4-architectureGenerate architecture documentation using C4 model Mermaid diagrams. Use when asked to create architecture diagrams, document system architecture, visualize software structure, or generate context/container/component/deployment diagrams./change-logCreate or update a structured change log for a product or platform. Use when someone asks to "create a change log", "log this change", "what changed", "update the change log", "release notes", or "changelog". Reads project memory (CLAUDE.local.md Recent Changes) and meeting /cli-anythingWrap any command-line tool into a JSON-emitting agent skill. Use when you want to make a CLI reliably callable and parseable by an AI agent — introspect its --help, define a structured-output (--json) contract and a stable error contract, then generate a SKILL.md wrapper with /clone-websiteClone any website into a pixel-perfect single-file HTML prototype. Extracts design tokens, assets, CSS computed styles, interaction patterns, and content via Playwright. Outputs a self-contained HTML file with real data injection. Use when the user wants to clone, replicate,/coco-adsTurn the project you just shipped into a short, polished, shareable launch video (an "ad") using HyperFrames. Use when someone says "/coco-ads", "make a launch video", "brag about this", "turn this into a promo", "make an ad for this", or wants to share what they built. Reads /coco-cliInstall, update, version-check, or uninstall the Coco open-source AI workflow framework via its CLI (cocosuperintelligence, run with npx). Use when setting up Coco on a machine, pulling the latest into an existing clone, checking the installed version, or removing it. Triggers /coco-loopStart a safe, governed autonomous loop from a plain-language goal. Use when the user says /coco-loop, "run an autonomous loop", "keep my build green for N hours", "work on X autonomously for a while", or wants a bounded self-improving loop that proposes fixes and never commits /cocoCoCo — your AI PM brain. Unified interface wrapping skills, commands, and knowledge tools. Invoke /coco to activate./code-verificationPost-implementation verification system that catches AI-introduced bugs. Covers 7 categories — TDZ errors, import mismatches, reference integrity, dead code, React state/effects, mock isolation, and CSS integrity. Run after every code change, after writing tests, or before /design-taste-frontendAnti-slop frontend skill for landing pages, portfolios, and redesigns. The agent reads the brief, infers the right design direction, and ships interfaces that do not look templated. Real design systems when applicable, audit-first on redesigns, strict pre-flight check./dispatching-parallel-agentsUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies /doc-syncUse when a project has linked documentation artifacts (PRDs, presentations, meeting notes, architecture maps) that must stay synchronized. Detects which source files changed, identifies downstream documents needing updates, reads new content, and proposes specific edits with /dr-planGenerate a Disaster Recovery plan with RTO/RPO targets. Use when someone asks to "create a DR plan", "disaster recovery", "business continuity", or "RTO RPO". Do NOT use for step-by-step restoration runbooks — use /pmstudio-recovery instead. Designed for SaaS platform products /executing-plansUse when you have a written implementation plan to execute in a separate session with review checkpoints /expo-api-routesGuidelines for creating API routes in Expo Router with EAS Hosting /find-skillsHelps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist /finishing-a-development-branchUse when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup /frontend-designCreate distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or /generate-testsGenerate complete test coverage for any file, component, or module. Covers unit tests, integration tests, edge cases, error handling, and mocking — adapted to whatever testing framework the project uses./humanizerRemove signs of AI-generated writing from text. Use when editing or reviewing text to make it sound more natural and human-written. Based on Wikipedia's comprehensive "Signs of AI writing" guide. Detects and fixes patterns including: inflated symbolism, promotional language,/irpGenerate an Incident Response Plan (IRP) with severity classification, escalation procedures, and communication templates. Use when someone asks to "create an incident response plan", "IRP", "incident procedures", "escalation matrix", "incident playbook", or needs to document /journey-mapLoads full context for a React Flow (@xyflow/react) user journey mapping project. Use when working on, extending, debugging, or building features for the journey map tool. Triggers on: "journey map project", "open journey map", "work on journey map", "build user journey", "react /karpathy-guidelinesBehavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria./media-memoryMultimodal memory — ingest, embed, and search media (images, video, audio, files) with Gemini Embedding 2 + ChromaDB /meeting-notesGenerate structured meeting notes from transcripts or pasted text. Use when someone says "meeting notes", "process this transcript", "summarize this call", "notes from today's meeting", or pastes/references a meeting transcript. Auto-enriches attendees from stakeholder /nfr-trackerDetailed completeness audit of all project documents. Use when someone asks "are we ready for production", "audit our docs", "readiness check", "nfr tracker", or "what's missing". Do NOT use for a quick command listing — use /pmstudio instead. Scans every document for /openai-agentsBuild AI applications with OpenAI Agents SDK - text agents, voice agents, multi-agent handoffs, tools with Zod schemas, guardrails, and streaming. Prevents 11 documented errors. Use when: building agents with tools, voice agents with WebRTC, multi-agent workflows, or /openai-apiBuild with OpenAI stateless APIs - Chat Completions (GPT-5.2, o3), Realtime voice, Batch API (50% savings), Embeddings, DALL-E 3, Whisper, and TTS. Prevents 16 documented errors. Use when: implementing GPT-5 chat, streaming, function calling, embeddings for RAG, or /openai-apps-mcpBuild ChatGPT apps with MCP servers on Cloudflare Workers. Extend ChatGPT with custom tools and interactive widgets (HTML/JS UI). Use when: developing ChatGPT extensions, implementing MCP servers, or troubleshooting CORS, widget 404s, MIME types, ASSETS binding errors, Next.js /openai-whisperSpeech-to-text transcription via OpenAI Whisper. Supports two modes — Local CLI (no API key, runs on-device) and Cloud API (fast, scalable, requires OPENAI_API_KEY). Use when the user needs to transcribe audio files, translate speech, or convert audio to text./pmstudioPM Studio command center. Use for a quick overview of available commands and document inventory. Use when someone says "pmstudio", "show commands", "what can I generate", or "project status". Do NOT use for detailed completeness audits — use /pmstudio-nfr instead. Shows document /prd-generatorGenerate comprehensive Product Requirements Documents (PRDs) for product managers. Use this skill when users ask to "create a PRD", "write product requirements", "document a feature", or need help structuring product specifications./prd-masteryA skill that blends the wisdom of top industry experts, ensures token-efficient PRDs, and organizes outputs in a clear folder structure./project-docsUse when starting a new project, onboarding to an existing product, or setting up a documentation ecosystem for any initiative. Scaffolds the standard document set, folder structure, project memory, and doc-sync config. Works for software products, consulting engagements,/receiving-code-reviewUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation /recovery-planGenerate detailed service restoration runbooks with step-by-step procedures. Use when someone asks to "create recovery procedures", "restoration runbook", "recovery steps", "how to restore service", or needs tactical step-by-step procedures for recovering from disaster /redesign-existing-projectsUpgrades existing websites and apps to premium quality. Audits current design, identifies generic AI patterns, and applies high-end design standards without breaking functionality. Works with any CSS framework or vanilla CSS./requesting-code-reviewUse when completing tasks, implementing major features, or before merging to verify work meets requirements /scroll-worldBuild an immersive scroll-scrubbed "fly through the world" landing page for any industry or brand using Higgsfield. As the visitor scrolls, a pre-rendered camera flies from outside each scene into its interior, then flows on to the next scene with NO cuts — one continuous /skill-creatorGuide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations./stakeholder-commsGenerate templated stakeholder communications from project context. Use when someone asks to "write a go-live email", "create a status update", "onboard someone", "write an announcement", "steerco update", "incident summary", "change notification", or any stakeholder /subagent-driven-developmentUse when executing implementation plans with independent tasks in the current session /swiftui-liquid-glassImplement, review, or improve SwiftUI features using the iOS 26+ Liquid Glass API. Use when asked to adopt Liquid Glass in new SwiftUI UI, refactor an existing feature to Liquid Glass, or review Liquid Glass usage for correctness, performance, and design alignment./systematic-debuggingUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes /tailwind-patternsTailwind CSS v4 principles. CSS-first configuration, container queries, modern patterns, design token architecture. Use when building with Tailwind v4 or migrating from v3./task-prd-creatorUse this skill when users request new features, enhancements, bug fixes, or any work that needs planning. Creates structured task files and PRDs (Product Requirements Documents) before implementation. Activates for "I want to add X", "implement Y", "create a task for Z", "plan /test-driven-developmentUse when implementing any feature or bugfix, before writing implementation code /ui-ux-pro-maxUI/UX design intelligence. 50 styles, 21 palettes, 50 font pairings, 20 charts, 9 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check /ultra-thinkDeep, multi-dimensional analysis and problem solving. Activates systematic reasoning across technical, business, user, and system perspectives. Generates multiple solutions with trade-offs, then synthesizes into a clear recommendation./using-git-worktreesUse when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification /using-superpowersUse when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions /vercel-react-best-practicesReact and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching,/verification-before-completionUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always /visual-explainerGenerate self-contained HTML visual explanations for systems, code changes, plans, data, and technical concepts. Use for diagrams, architecture overviews, diff or plan reviews, project recaps, comparison tables, slide decks, and other visual explanations./voice-aiVoice AI architecture and implementation guide. Covers two architectures: speech-to-speech (OpenAI Realtime API, lowest latency) and pipeline (STT->LLM->TTS, more control). Includes provider-specific patterns for OpenAI Realtime, Vapi, Deepgram, ElevenLabs, and LiveKit. Use when /web-design-guidelinesReview UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices"./workflow-routingUse at the start of any task to route between Superpowers skills and GSD commands based on project state, task scope, and context signals. Fires before other skills when both systems are installed./writing-plansUse when you have a spec or requirements for a multi-step task, before touching code /writing-skillsUse when creating new skills, editing existing skills, or verifying skills work before deployment /brain-exportAuto-generate a slim CLAUDE.local.md from brain DB. Preserves manual behavior rules. Produces ~1,200 token auto-generated context section with key people, systems, decisions, and project status./brain-initInitialize a project_brain.db in the current project folder. Creates the database, project record, then scans existing files (CLAUDE.local.md, memory files, docs, emails) to bootstrap the brain with knowledge. Smart enough to handle re-runs — skips what already exists and only /brain-rescanIncremental rescan of project folder. Detects new/changed files since last scan, extracts knowledge from CLAUDE.local.md, memory files, and doc inventory, and updates the brain DB. Requires an existing project_brain.db — run /brain-init first if none exists./brain-updateEnd-of-session brain flush. Scans the full conversation, extracts all new entities, decisions, tasks, events, relationships, and updates, presents a summary, and writes to project_brain.db after confirmation. Use at end of every session or when you want to capture everything /brain-wikiBrowse, search, and generate Wikipedia-style knowledge articles from the brain. Auto-generated from brain DB entities, emails, docs, and decisions./brainSQLite-based project knowledge tracker. Manages entities, relationships, tasks, threads, decisions, and events per project folder. Use /brain to query or update project_brain.db. Triggers on: 'brain', 'project knowledge', 'what do we know about', 'open tasks', 'recent decisions'./cognee-recallSemantic and graph search across Cognee knowledge graph. Queries project memory, finds related entities and decisions, injects results as agent context. Triggers on: 'cognee recall', 'search memory', 'what do we know about', 'find related', 'graph search', 'memory search',/cognee-storePush project knowledge into the Cognee knowledge graph. Stores entities, decisions, events, relationships, and session context. End-of-session flush that extracts everything from the conversation and writes to the graph. Triggers on: 'cognee store', 'push to cognee', 'save to /cogneeKnowledge graph memory backend powered by Cognee. Query, status check, dataset management, and backend switching between Brain and Cognee. Triggers on: 'cognee', 'knowledge graph', 'graph memory', 'switch memory', 'memory backend'./gsd-add-backlogAdd an idea to the backlog parking lot (999.x numbering)/gsd-add-phaseAdd phase to end of current milestone in roadmap /gsd-add-testsGenerate tests for a completed phase based on UAT criteria and implementation /gsd-add-todoCapture idea or task as todo from current conversation context /gsd-analyze-dependenciesAnalyze phase dependencies and suggest Depends on entries for ROADMAP.md /gsd-audit-fixAutonomous audit-to-fix pipeline — find issues, classify, fix, test, commit /gsd-audit-milestoneAudit milestone completion against original intent before archiving /gsd-audit-uatCross-phase audit of all outstanding UAT and verification items /gsd-autonomousRun all remaining phases autonomously — discuss→plan→execute per phase /gsd-check-todosList pending todos and select one to work on /gsd-cleanupArchive accumulated phase directories from completed milestones /gsd-code-review-fixAuto-fix issues found by code review in REVIEW.md. Spawns fixer agent, commits each fix atomically, produces REVIEW-FIX.md summary./gsd-code-reviewReview source files changed during a phase for bugs, security issues, and code quality problems /gsd-complete-milestoneArchive completed milestone and prepare for next version /gsd-debugSystematic debugging with persistent state across context resets /gsd-discuss-phaseGather phase context through adaptive questioning before planning. Use --auto to skip interactive questions (Claude picks recommended defaults). Use --chain for interactive discuss followed by automatic plan+execute. Use --power for bulk question generation into a file-based UI /gsd-doRoute freeform text to the right GSD command automatically /gsd-docs-updateGenerate or update project documentation verified against the codebase /gsd-execute-phaseExecute all plans in a phase with wave-based parallelization /gsd-exploreSocratic ideation and idea routing — think through ideas before committing to plans /gsd-fastExecute a trivial task inline — no subagents, no planning overhead /gsd-forensicsPost-mortem investigation for failed GSD workflows — analyzes git history, artifacts, and state to diagnose what went wrong /gsd-healthDiagnose planning directory health and optionally repair issues /gsd-helpShow available GSD commands and usage guide /gsd-importIngest external plans with conflict detection against project decisions before writing anything./gsd-insert-phaseInsert urgent work as decimal phase (e.g., 72.1) between existing phases /gsd-intelQuery, inspect, or refresh codebase intelligence files in .planning/intel//gsd-join-discordJoin the GSD Discord community /gsd-list-phase-assumptionsSurface Claude's assumptions about a phase approach before planning /gsd-list-workspacesList active GSD workspaces and their status /gsd-managerInteractive command center for managing multiple phases from one terminal /gsd-map-codebaseAnalyze codebase with parallel mapper agents to produce .planning/codebase/ documents /gsd-milestone-summaryGenerate a comprehensive project summary from milestone artifacts for team onboarding and review /gsd-new-milestoneStart a new milestone cycle — update PROJECT.md and route to requirements /gsd-new-projectInitialize a new project with deep context gathering and PROJECT.md /gsd-new-workspaceCreate an isolated workspace with repo copies and independent .planning//gsd-nextAutomatically advance to the next logical step in the GSD workflow /gsd-noteZero-friction idea capture. Append, list, or promote notes to todos./gsd-pause-workCreate context handoff when pausing work mid-phase /gsd-plan-milestone-gapsCreate phases to close all gaps identified by milestone audit /gsd-plan-phaseCreate detailed phase plan (PLAN.md) with verification loop /gsd-plant-seedCapture a forward-looking idea with trigger conditions — surfaces automatically at the right milestone /gsd-pr-branchCreate a clean PR branch by filtering out .planning/ commits — ready for code review /gsd-profile-userGenerate developer behavioral profile and create Claude-discoverable artifacts /gsd-progressCheck project progress, show context, and route to next action (execute or plan)/gsd-quickExecute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents /gsd-reapply-patchesReapply local modifications after a GSD update /gsd-remove-phaseRemove a future phase from roadmap and renumber subsequent phases /gsd-remove-workspaceRemove a GSD workspace and clean up worktrees /gsd-research-phaseResearch how to implement a phase (standalone - usually use /gsd-plan-phase instead)/gsd-resume-workResume work from previous session with full context restoration /gsd-review-backlogReview and promote backlog items to active milestone /gsd-reviewRequest cross-AI peer review of phase plans from external AI CLIs /gsd-scanRapid codebase assessment — lightweight alternative to /gsd-map-codebase /gsd-secure-phaseRetroactively verify threat mitigations for a completed phase /gsd-session-reportGenerate a session report with token usage estimates, work summary, and outcomes /gsd-set-profileSwitch model profile for GSD agents (quality/balanced/budget/inherit)/gsd-settingsConfigure GSD workflow toggles and model profile /gsd-shipCreate PR, run review, and prepare for merge after verification passes /gsd-statsDisplay project statistics — phases, plans, requirements, git metrics, and timeline /gsd-threadManage persistent context threads for cross-session work /gsd-ui-phaseGenerate UI design contract (UI-SPEC.md) for frontend phases /gsd-ui-reviewRetroactive 6-pillar visual audit of implemented frontend code /gsd-undoSafe git revert. Roll back phase or plan commits using the phase manifest with dependency checks./gsd-updateUpdate GSD to latest version with changelog display /gsd-validate-phaseRetroactively audit and fill Nyquist validation gaps for a completed phase /gsd-verify-workValidate built features through conversational UAT /gsd-workstreamsManage parallel workstreams — list, create, switch, status, progress, complete, and resume /embedded-captionsAdd captions or subtitles to an existing single-subject talking-head video without editing the footage. Use for plain verbatim captions, cinematic captions embedded behind the subject, VFX captions, “炸/特效/酷炫字幕,” or a named identity from the 35-style catalog. Route by visual /faceless-explainerTurn arbitrary text — an article, notes, a topic, a brief — into a faceless explainer video: there is no site or footage to capture, so the visuals are invented per scene (typography, abstract graphics, diagrams, data-viz). Use for topic explainers, concept breakdowns, how-tos,/figmaImport Figma content into a HyperFrames composition — rendered assets, brand tokens, components, storyboard sections → reconstructed motion (frames read as states, not slides) (REST/CLI), connector-assisted motion when available, and shaders from a connector or native export./general-videoAuthor or edit a custom HyperFrames composition when no specialized workflow fits, or when BRIEF.md sets flow: companion. Use for longer or multi-scene pieces, brand and sizzle reels, montages, static loops, static title cards, footage remixes, and freeform builds. Use /hyperframes-animationAll animation knowledge for HyperFrames — atomic motion rules, multi-phase scene blueprints, scene transitions, broader motion-design techniques, AND the seven runtime adapters (GSAP default, plus Lottie, Three.js, Anime.js, CSS keyframes, Web Animations API, TypeGPU). Use for /hyperframes-cliUse the HyperFrames CLI development loop: init, add, catalog, capture, lint, check, snapshot, compare, grade-compare, preview, play, present, beats, keyframes, single or batch render, publish, cloud, cloudrun, feedback, lambda, doctor, browser, info, upgrade, skills,/hyperframes-coreThe HyperFrames composition contract — build one renderable project. Use for composition structure, the `data-*` timing attributes, `class="clip"`, tracks, sub-compositions, variables, framework-owned media playback, deterministic-render rules, and validation. Also covers /hyperframes-creativeNon-animation creative direction for HyperFrames videos. Use for design spec (frame.md / design.md) handling, palettes, typography, narration, beat planning, audio-reactive visuals, composition patterns, and brand / style decisions. For atomic motion patterns and scene /hyperframes-keyframesUse when a HyperFrames composition needs seek-safe 2D/3D keyframes, GSAP timelines, CSS keyframes, Anime.js, WAAPI, FLIP, paths, masks, SVG morph/draw, text trails, 3D depth, or `hyperframes keyframes` diagnostics. Don't use for broad scene strategy, brand design, media /hyperframes-registryInstall, discover, and wire registry blocks and components into HyperFrames compositions. Use when running hyperframes add or hyperframes catalog, installing one item or every block matching a tag, wiring an installed item into index.html, or working with hyperframes.json./hyperframesMandatory entry point: read this first for any request to make, create, edit, animate, or render a video, animation, or motion graphic, including a promo, explainer, captioned clip, title card, overlay, slideshow or interactive deck, Remotion port, or any HyperFrames HTML /media-useAgent Media OS, the single skill for every media need in a HyperFrames project. Resolve BGM, SFX, image, icon, brand logo, voice, color grade, or LUT into a frozen local file or paste-ready block + ledger record (one verb, `resolve`); generate via TTS / music / image models when /motion-graphicsA short, design-led motion graphic where motion is the message — kinetic typography, stat count-up, chart/data-viz hit, logo sting / brand lockup, lower-third / callout / social overlay, animated map (highlight regions, connect places, zoom to a location), animated tweet //music-to-videoTurn a music track (an audio file, a video to pull audio from, or a track generated from a mood brief) into a beat-synced video — lyric video, slideshow, or kinetic promo. The music drives all pacing; any user-supplied images/videos are cut onto the same beat grid, and a /pr-to-videoTurn a GitHub pull request (a PR URL, owner/repo#N, or 'this PR' in a checked-out repo) into a code-change explainer video — changelog, feature reveal, fix, or refactor walkthrough built from the diff, commits, and files: the input is a code change, not a website. Not a product /product-launch-videoTurn a product or marketing URL, pasted script, or brief into a product launch / promo video — SaaS promos, feature reveals, product demos, app and company launches. Use when the user wants to market, launch, promote, or reveal a product; the default for any commercial URL. Site /remotion-to-hyperframesPort an existing Remotion (React) composition''s source to HyperFrames HTML. Use ONLY on an explicit ask to port/convert/migrate/translate a Remotion source — one-way, Remotion-only. A passing Remotion mention, reference-only code, or "make something like my Remotion video" is a /slideshowAuthor a HyperFrames slideshow — a presentation, pitch deck, or interactive deck with discrete slides, fragment reveals, branching, hotspot navigation, and built-in presenter mode with speaker notes; also converts an existing page into a deck. Output is a navigable deck, not a /talking-head-recutPackage an existing talking-head / interview / podcast video with timed, designed GRAPHIC OVERLAY cards — kinetic titles, lower-thirds, data callouts, quotes, side panels, picture-in-picture — synced to the transcript, on a 16:9 / 9:16 / 4:5 canvas of your choice; the clip plays /website-to-videoCapture a general website/URL and turn it into a video OF the site — tour, showcase, or social clip built from captured screenshots and the site's own brand assets. Use for portfolio / blog / docs / landing-page showcases. Not a product launch or promo, even from a URL /m0-handoffSession handoff and resume for M0. Write a compact_checkpoint before a session ends or context is compacted, and resume from the latest one at the start of a session in any tool. Turns a cold start into a continuation. Triggers on: 'm0 handoff', 'hand off', 'session handoff',/m0-recallRead the recent M0 operational thread for a project, newest first, to pick up work started in this or another tool. Answers 'where were we' and 'what is next' before asking the user to repeat context. Local SQLite, no embeddings, no network. Triggers on: 'm0 recall', 'where were /m0-rememberWrite one entry to the M0 operational thread so the next session, in this tool or any other, can continue the work. Records a completed step, a decision, a verification result, or a dispatched lane. Idempotent and local-only. Triggers on: 'remember this', 'm0 remember', 'save to /m0Cross-tool agent memory control plane. Start, stop, and check the M0 operational-thread server; find the store; drain deferred writes; wire the MCP tools and session hooks. Local SQLite, no dependencies, no network. Triggers on: 'm0', 'm0 status', 'start m0', 'cross-tool

Agents

ai-engineerSenior AI engineer for architecting, implementing, and optimizing end-to-end AI systems — from model selection and training pipelines to production deployment, monitoring, and ethical governance. Use proactively when designing AI architectures, selecting models, building code-reviewerSenior code and architecture reviewer for comprehensive quality, security, performance, and architectural integrity analysis. Use proactively after writing or modifying code, before merging PRs, when reviewing structural changes, designing services, or evaluating API data-specialistSenior data specialist covering exploratory analysis, statistical modeling, machine learning, experimentation, SQL optimization, query design, and performance tuning across major database platforms. Use proactively when analyzing datasets, building predictive models, running A/B database-architectDatabase architecture and design specialist. Use PROACTIVELY for database design decisions, data modeling, scalability planning, microservices data patterns, database technology selection, migration strategies, and performance optimization.mcp-specialistMCP (Model Context Protocol) specialist covering server/client development, configuration, troubleshooting, tool setup, architecture, transport layers, and protocol compliance against the MCP 2025-06-18 spec. Use proactively when building MCP servers, configuring MCP pm-advisorProduct management advisor for feature planning, issue creation, prioritization, and data-driven product decisions. Use proactively when planning features, writing user stories, creating GitHub/Jira issues, prioritizing a backlog, defining acceptance criteria, structuring epics,

Show all 37 agents

refactoring-specialistSenior refactoring specialist for transforming complex, poorly structured code into clean, maintainable systems. Use proactively when code quality metrics show complexity issues, code smells are detected, maintainability is suffering, or legacy code needs safe incremental test-guardianEnsures tests actually test what they claim. Catches tautological assertions, mock leakage, tests that pass for wrong reasons, missing edge cases. Run after writing or modifying tests.typescript-proAdvanced TypeScript specialist for type-level programming, complex generics, end-to-end type safety, monorepo architecture, and large-scale migrations. Use when implementing advanced type patterns (conditional types, mapped types, template literals, branded types), architecting ui-ux-designerResearch-backed UI/UX design critic providing opinionated, evidence-based feedback on interfaces. Use proactively when reviewing UI code, designing layouts, choosing typography or color palettes, auditing accessibility, evaluating mobile UX, or fighting generic SaaS aesthetics.gsd-advisor-researcherResearches a single gray area decision and returns a structured comparison table with rationale. Spawned by discuss-phase advisor mode.gsd-assumptions-analyzerDeeply analyzes codebase for a phase and returns structured assumptions with evidence. Spawned by discuss-phase assumptions mode.gsd-code-fixerApplies fixes to code review findings from REVIEW.md. Reads source files, applies intelligent fixes, and commits each fix atomically. Spawned by /gsd-code-review-fix.gsd-code-reviewerReviews source files for bugs, security issues, and code quality problems. Produces structured REVIEW.md with severity-classified findings. Spawned by /gsd-code-review.gsd-codebase-mapperExplores codebase and writes structured analysis documents. Spawned by map-codebase with a focus area (tech, arch, quality, concerns). Writes documents directly to reduce orchestrator context load.gsd-debuggerInvestigates bugs using scientific method, manages debug sessions, handles checkpoints. Spawned by /gsd-debug orchestrator.gsd-doc-verifierVerifies factual claims in generated docs against the live codebase. Returns structured JSON per doc.gsd-doc-writerWrites and updates project documentation. Spawned with a doc_assignment block specifying doc type, mode (create/update/supplement), and project context.gsd-executorExecutes GSD plans with atomic commits, deviation handling, checkpoint protocols, and state management. Spawned by execute-phase orchestrator or execute-plan command.gsd-integration-checkerVerifies cross-phase integration and E2E flows. Checks that phases connect properly and user workflows complete end-to-end.gsd-intel-updaterAnalyzes codebase and writes structured intel files to .planning/intel/.gsd-nyquist-auditorFills Nyquist validation gaps by generating tests and verifying coverage for phase requirements gsd-phase-researcherResearches how to implement a phase before planning. Produces RESEARCH.md consumed by gsd-planner. Spawned by /gsd-plan-phase orchestrator.gsd-plan-checkerVerifies plans will achieve phase goal before execution. Goal-backward analysis of plan quality. Spawned by /gsd-plan-phase orchestrator.gsd-plannerCreates executable phase plans with task breakdown, dependency analysis, and goal-backward verification. Spawned by /gsd-plan-phase orchestrator.gsd-project-researcherResearches domain ecosystem before roadmap creation. Produces files in .planning/research/ consumed during roadmap creation. Spawned by /gsd-new-project or /gsd-new-milestone orchestrators.gsd-research-synthesizerSynthesizes research outputs from parallel researcher agents into SUMMARY.md. Spawned by /gsd-new-project after 4 researcher agents complete.gsd-roadmapperCreates project roadmaps with phase breakdown, requirement mapping, success criteria derivation, and coverage validation. Spawned by /gsd-new-project orchestrator.gsd-security-auditorVerifies threat mitigations from PLAN.md threat model exist in implemented code. Produces SECURITY.md. Spawned by /gsd-secure-phase.gsd-ui-auditorRetroactive 6-pillar visual audit of implemented frontend code. Produces scored UI-REVIEW.md. Spawned by /gsd-ui-review orchestrator.gsd-ui-checkerValidates UI-SPEC.md design contracts against 6 quality dimensions. Produces BLOCK/FLAG/PASS verdicts. Spawned by /gsd-ui-phase orchestrator.gsd-ui-researcherProduces UI-SPEC.md design contract for frontend phases. Reads upstream artifacts, detects design system state, asks only unanswered questions. Spawned by /gsd-ui-phase orchestrator.gsd-user-profilerAnalyzes extracted session messages across 8 behavioral dimensions to produce a scored developer profile with confidence levels and evidence. Spawned by profile orchestration workflows.gsd-verifierVerifies phase goal achievement through goal-backward analysis. Checks codebase delivers what phase promised, not just that tasks completed. Creates VERIFICATION.md report.builderTurn `shot-plan.json` into one renderable HyperFrames composition (`compositions/index.html`). Everything stays in the HF ecosystem — HTML is the source of truth; a single **paused** GSAP timeline carries all motion; the engine seeks it. Category-specific build rules live in directorTurn a request into a `shot-plan.json` for a short (~3–30s) **design-led motion graphic**. You run in **two parts** around the asset-sourcing step: **Part 1 (plan)** before sourcing, **Part 2 (design)** after. You do NOT write composition code — that's the Builder. Schema:finalizePerform snapshot QA and one in-place repair pass. Dispatch only when Step 5 `lint`, `check`, or snapshot review reports a defect. The orchestrator owns final approval and render; this agent never renders.

Commands

/mermaidBuild beautiful Mermaid diagrams using beautiful-mermaid. Covers all 6 diagram types, theming, SVG/ASCII output, and CoCo Platform integration./readShow latest emails from a specific person. Usage: /email-read alice /replyDraft a reply to a specific email. Usage: /email-reply Project Phase 2 Contract Data /saveSave matching emails to a project folder for sync processing. Usage: /email-save alice to emails//searchSearch emails by subject keywords. Usage: /email-search github webhook /summaryAI summary of today's emails — key decisions, action items, meetings. No arguments needed.

Show all 41 commands

README

Read on GitHub

CoCo Super Intelligence

Summon an advisory board of 389 world-class minds — right inside your AI coding session.

CoCo Super Intelligence is the orchestration layer that turns Claude Code, Cursor, or Codex into an entire engineering department: routed expert panels that deliberate and decide, then 179 skills, 279 commands, and disk-persistent state that ship what they decided.

Open-core (MIT core · proprietary Super Intelligence) · installs in 90 seconds · 100% local · no telemetry

One developer writing single prompts? That was last year.

CoCo Super Intelligence convenes a cross-team board of 389 named experts to pressure-test your hardest calls — then puts an orchestrated team of agents to work executing the verdict: parallel build waves, deterministic verification gates, and phase state that survives every /clear.

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

What CoCo Is (and Isn't)

CoCo is not a new AI model, and it is not another agent harness. It doesn't run a model or an agent loop of its own. It's a portable layer of Markdown and YAML that installs into the agent harness you already use — Claude Code, Cursor, Codex CLI, or any AGENTS.md-compatible tool — and upgrades it with an expert advisory board, a skills library, persistent project memory, specialized subagents, and verification gates.

Your model, your tool, your keys, your machine. When you see "parallel subagent waves," those subagents are executed by your host harness's own agent machinery; CoCo supplies the orchestration structure that makes it all behave like a coordinated team. That is exactly why CoCo is vendor-neutral: it's the operating layer, not the engine.

⭐ The Board — CoCo Super Intelligence

A cross-team advisory board of 389 world-class minds

Super Intelligence is CoCo's signature capability. It lets you summon custom, real-world expert panels directly inside your coding session to guide architectural, engineering, risk, finance, and business decisions — each contribution attributed to a named expert, grounded in cited public sources.

/SI-Decide "Should we migrate our database to pgvector?"
/SI-AI-Decide "Which embedding model gives the best cost/performance?"
/SI-Eng-Pre-Mortem "Review our zero-downtime cache migration strategy"
/SI-GRC-Review "Check this customer onboarding flow for GDPR compliance"

389 expert personas, organized across 9 specialized departments:

Department	Experts	Focus
Engineering	70	Software architecture, cloud systems, systems coding, compilers, infrastructure
AI	59	Neural-network research, LLM optimization, safety, alignment, vector databases
Product & Design	56	Design systems, UX, product strategy, growth loops
Finance	47	Valuation, corporate finance, macro modeling, fintech infrastructure
Trading	46	Quant analysis, market microstructure, derivatives pricing, crypto liquidity
Risk & Compliance (GRC)	30	GDPR, HIPAA, SOC 2, security auditing, international regulation
Strategy	29	Platform economics, business models, competitive analysis
Data & Analytics	29	Data engineering, pipeline optimization, predictive modeling
Sales / GTM / Marketing	23	Product-market fit, sales ops, growth marketing, enterprise GTM

242 generated slash commands. 17 cross-team meta commands (like /SI-Decide or /SI-Tradeoff, routing across domains) plus 225 per-team commands (25 verbs × 9 teams, such as /SI-AI-Decide or /SI-Eng-Pre-Mortem). These are generated locally at install time from the team registries — no command files are transmitted or stored remotely.
70 expertise cells. Each department is subdivided into focused cells (e.g. Engineering has 11, AI has 8) so the router can assemble a precise panel rather than a generic crowd.
Cross-team meta-orchestration. For complex queries spanning domains ("build and sell an AI audit tool"), a local router scores your prompt against team registries and cells, then greedily assembles a proportional 16–32-person panel.
Citable and grounded. Every stance is verified from public sources and carries a direct evidence URL. Personas are validated against a strict anti-fabrication gate.
--debate deliberation. Panels can argue in reacting rounds before returning a verdict, surfacing named dissent instead of false consensus.

The selection algorithm (two-stage routing + approval)

The meta-orchestrator uses a staged algorithm so it never has to load the entire persona filesystem at runtime:

Stage A — team & cell routing (cheap). Reads the meta-registry (systems/superintelligence/registry.json) and scans only team descriptions and cell definitions, scoring relevance by keyword and domain overlap to select the top 1–4 teams. If one team dominates, it delegates to that team's own orchestrator.
Stage B — scoped persona selection. Loads compact persona records (slugs, cells, domains, stances, conflict mappings) for only the selected teams, allocates the 16–32-person budget proportionally, runs the greedy scorer (0.40·domain + 0.30·cell-coverage + 0.30·conflict-pairing), and applies a cross-team tension pass to pair opposing viewpoints (e.g. security vs. growth).
Stage C — approval & execution. Presents the roster grouped by team with a one-line rationale. The action verb then consumes the approved roster and returns output with full line-by-line attribution (e.g. "Aswath Damodaran (Finance): …").

Persona build & validation pipeline

The 389-persona roster was compiled with a systematic multi-tier workflow. Candidate generation was evaluated across local Qwen (via LM Studio), a hosted small model, and Gemini Flash, but Claude research agents proved the quality winner for resolving historical data and citing verifiable signal. Personas are checked by an advisory validation gate (validate_persona.py) that enforces five things: every required frontmatter field is present; at least 4 cited URLs resolve live (non-404); every public_stance carries an evidence_url, so no stance is uncited; at least 2 recent signals within 12 months (or 2 persistent signals for historical archetypes); and any pairs_well_with / productive_conflict_with slug refers to a real roster member. Two limits are worth stating plainly: the gate confirms that a stance is cited, not that a quotation is authentic, and home_team is only checked for presence, not validated against the list of real teams. A NEEDS-TOPUP verdict is advisory — it does not currently affect which personas a council selects at runtime.

The Framework Underneath

The board decides. The framework ships. Three pillars turn the verdict into merged, verified code.

1. Autonomous team execution

/team:ship runs a fully coordinated build pipeline — 6 development stages, 7 hard verification gates, and 2 architecture conformance gates. Specialized agents act in their domains (Research, Architecture, Plan, Review, Build, QA). Code must clear the Test Evidence Protocol (independent re-runs, strict coverage, skip-prevention) and land where the plan said it would before a pull request is opened.

2. Disk-persistent state

AI chat context is fragile and wipes on /clear. CoCo persists phase state, decisions, and progress logs to disk across resets, with atomic git commits for every successful step — so you can review history, roll back a bad design path, or resume a long-running migration from any checkpoint.

3. Vendor-neutral portability

CoCo compiles its rules, templates, and agent definitions into pure Markdown and YAML frontmatter. Native IDE adapters inject the same library into Claude Code, Cursor, Codex CLI, or any AGENTS.md tool — so your workflows follow you even if you switch AI editors.

Architecture conformance: the gate tests cannot give you

Every test suite in existence shares one blind spot. Tests fail when behaviour breaks — not when your architecture quietly dissolves. A component can be relocated, folded into another module, or deleted outright, and a green build will tell you nothing. Requirements pass. Coverage holds. The design you agreed to is gone.

/team now closes that gap in both directions, and both are enforced by Python scripts with real exit codes — not by instructions an agent can narrate its way around.

◀ Backwards — drift detection

A commit-pinned index at .arch/index.json maps every architectural component to the real directories and files that implement it. /team:verify gained failure mode (e): structural drift against that index.

Twelve validator checks run on every index. The central one is blunt and unfakeable: every claimed path must resolve on disk. A fabricated path exits non-zero and names itself.

▶ Forwards — built as declared

/team:ship Stage 3 now declares its intended architecture to .team-ship/ARCH-PLAN.json — where each component will live, and what is explicitly out of scope.

After the build, the built-as-declared gate checks it. A component you declared and then quietly dropped is a BLOCK. A file that lands in a path the plan ruled out of scope is a BLOCK. Neither appears in any test result.

Why this works. Path existence cannot be checked at planning time, because nothing is built yet. So the plan is written when the knowledge exists and tested when the evidence exists. Deferring the check rather than weakening it is exactly what makes a forward architecture declaration enforceable.

Use it

/team arch build      # map this repository into a committed, commit-pinned index
/team arch drift      # reconcile an existing index against the current tree
/team arch check      # run the validator alone — no model calls, no writes to the index
/team verify          # now includes failure mode (e): architecture abandoned
/team ship            # declares intended architecture, then proves the build matches
/team ship --no-arch  # opt out entirely; every gate reports DISABLED, never a silent pass

The approval gate now shows you the intended architecture as a table before the build starts. That is the cheapest moment to disagree with it.

What it does not do

A gate that overstates its reach is worse than no gate, so these limits are stated in the artifacts themselves and are not marketing hedges.

Structural drift only. A component whose datastore was swapped inside its own already-claimed directory produces no drift. Every artifact says "structural drift only" in those words, deliberately.
Not a work-allocation mechanism. The index sits at C4-Container altitude, so one component can legitimately own thousands of files. Three separate design reviews rejected deriving per-agent file ownership from it.
Currency is not yet mechanically enforced. Comparing the index pin to HEAD is prose an agent follows, not a script. A stale index degrades every gate to UNVERIFIED rather than to a pass — but instrumenting this is the next piece of work, and it is named as such.
A clean result licenses no claim about whether the code at those paths does what the component promised. That remains a review judgement.

Requires only Python 3 and git. No new dependencies. Design adapted from lak7/devildev (Apache-2.0); no upstream code was copied — see CREDITS.md.

The CoCo Asset Library

A standard install equips your workspace with a lightweight core; full activation unlocks up to 896 total assets to orchestrate any software-engineering workflow.

Skills Catalog

CoCo ships 179 skills (68 core + 111 across bundles). These are not prompt snippets — each is a full agent instruction set with state management, verification logic, and error handling. A representative slice by category:

Visual design & styling

ui-ux-pro-max (50 styles, 21 palettes, 50 font pairings, 9 stacks) · frontend-design · design-taste-frontend · redesign-existing-projects · axiom-liquid-glass (Apple Liquid Glass, WWDC 2025) · swiftui-liquid-glass · web-design-guidelines · tailwind-patterns (Tailwind v4) · vercel-react-best-practices · clone-website · c4-architecture · arb-review · expo-api-routes · ai-product · scroll-world (scroll-scrubbed, cut-free camera flythrough landing pages, generated end to end via Higgsfield).

Engineering discipline & quality

brainstorming · writing-plans · executing-plans · subagent-driven-development · dispatching-parallel-agents · test-driven-development · systematic-debugging · requesting-code-review · receiving-code-review · verification-before-completion · finishing-a-development-branch · using-git-worktrees · code-verification (7 bug-vector audit) · generate-tests · api-design-principles · cli-anything · workflow-routing.

AI / LLM engineering

openai-agents · openai-api · openai-apps-mcp · openai-whisper · agent-lightning (Microsoft Agent Lightning, RL) · voice-ai · ai-marketing-videos.

Product management & communication

prd-generator · prd-mastery · task-prd-creator · project-docs · pmstudio · nfr-tracker · stakeholder-comms · meeting-notes · change-log.

Operations, safety & recovery

dr-plan (RTO/RPO) · irp (incident response) · recovery-plan.

Media, memory & analysis

coco-ads (launch videos via HyperFrames) · media-memory (multimodal embeddings) · doc-sync · ultra-think · browser-automation.

The CoCo platform itself

coco (conversational router) · coco-cli · coco-loop (compiles a plain-language goal into a confirmed charter, then runs a bounded, propose-only autonomous loop) · skill-creator · writing-skills · find-skills.

Core skills (66)

agent-lightning · ai-marketing-videos · ai-product · api-design-principles · arb-review · axiom-liquid-glass · brainstorming · browser-automation · c4-architecture · change-log · cli-anything · clone-website · coco · coco-ads · coco-cli · coco-loop · code-verification · design-taste-frontend · dispatching-parallel-agents · doc-sync · dr-plan · executing-plans · expo-api-routes · find-skills · finishing-a-development-branch · frontend-design · generate-tests · irp · media-memory · meeting-notes · nfr-tracker · openai-agents · openai-api · openai-apps-mcp · openai-whisper · pmstudio · prd-generator · prd-mastery · project-docs · receiving-code-review · recovery-plan · redesign-existing-projects · requesting-code-review · scroll-world · skill-creator · stakeholder-comms · subagent-driven-development · swiftui-liquid-glass · systematic-debugging · tailwind-patterns · task-prd-creator · test-driven-development · ui-ux-pro-max · ultra-think · using-git-worktrees · using-superpowers · vercel-react-best-practices · verification-before-completion · voice-ai · web-design-guidelines · workflow-routing · writing-plans · writing-skills

GSD bundle skills (68) — the full gsd-* project-orchestration lifecycle: gsd-new-project, gsd-plan-phase, gsd-execute-phase, gsd-verify-work, gsd-autonomous, gsd-debug, gsd-ui-phase, gsd-secure-phase, gsd-workstreams, gsd-forensics, gsd-milestone-summary, gsd-map-codebase, gsd-profile-user, and 55 more (see systems/gsd/skills/).

Brain bundle skills (6) — brain · brain-init · brain-rescan · brain-update · brain-export · brain-wiki.

Super Intelligence bundle (9) — one orchestration skill per built team (ai, engineering, product-design, finance, trading, risk-compliance, strategy, data-analytics, gtm), which generate the 242 /SI-* commands at install.

System Bundles

Bundles are opt-in packages that extend the workspace with specialized databases, pipelines, and rosters. Enable them with --systems <name>.

1. GSD (Get Shit Done)

An orchestration engine of 68 skills and 24 agents that manages the lifecycle of complex codebases. A disk-backed phase database records goals, decisions, milestones, and blockers; workstreams spin up isolated git checkouts to test refactors without polluting main; forensics performs post-mortem root-cause audits when a phase fails; and autonomous mode runs parallel waves of subagents through plan milestones end-to-end.

2. Brain

A local knowledge-graph engine of 6 skills connecting email, chat, code, and docs. A local SQLite store indexes code entities, business decisions, project terms, and stakeholder feedback; a wiki generator builds hyperlinked articles for every recorded entity; and mail sync links project email threads to related files.

3. Team

A multi-agent product-team pipeline (/team:ship, /team:plan, /team:review, /team:verify, and more). It spawns specialized subagents — Research, Architect, QA — to execute changes, review diffs, and write tests, with deterministic gates that intercept merges to run lints, import audits, reference checks, and verification suites.

4. Super Intelligence

The 389-persona advisory board and its 242 generated /SI-* commands across 9 departments — the hero capability described above.

YOLO Mode: True Autonomy

/coco yolo

Bypass approval gates and let the team run unattended. Activates autonomous multi-stage execution — pipelines advance phase to phase without manual confirmation. Combine with /gsd-autonomous and --systems gsd to run code migrations or test sweeps overnight. Revert to safety any time with /coco careful or /coco normal.

Before CoCo vs. After CoCo

High-Impact Command Demos

Cross-team decision

/SI-Decide --debate "Buy vs. build our vector store"

Routes a proportional expert panel, deliberates in reacting rounds, and returns an attributed verdict with named dissent.

Code-integrity verification

/code-verification

Audits fresh code against 7 bug vectors, preventing broken references, imports, and mock leakage.

Website re-engineering

/clone-website https://stripe.com

Extracts colors, typography, spacing, shadows, and SVG assets from a live URL into a single-file responsive template.

Systematic debugging

/systematic-debugging

Drives a methodical root-cause isolation workflow, preserving hypotheses and findings across API limits.

Spec & PRD generation

/prd-generator

Produces a comprehensive PRD — user stories, metrics, risks, architecture.

Launch video

/coco-ads

Turns the project you just shipped into a short, shareable launch video, rendered locally via HyperFrames.

Power Features

CoCo conversational router

/coco

A central dashboard that routes plain-English asks — "what's blocking?", "summarize files", "run tests" — to the right sub-command.

Multimodal memory

/media-memory

A local embedding database (Gemini Embedding + ChromaDB) that indexes, searches, and associates diagrams, audio, and docs with your code.

Scheduled & loop agents

# Point your host CLI's scheduler at any CoCo command:
/schedule run /team:review every Monday
/loop 5m /team:verify

CoCo ships no scheduler of its own. Where your host CLI provides scheduling or looping (such as Claude Code's /schedule and /loop), point it at any CoCo command to run reviews or watches unattended.

Email triage suite

/email:summary
/email:today

Reads your active Outlook instance (Legacy AppleScript or New Outlook MIME cache) to fetch, search, thread, and draft replies to project mail.

Workspace branching

/gsd-workstreams create feature-a
/gsd-new-workspace

Branch development workstreams within one repo — isolated, sandboxed checkouts with separate project state.

AGENTS.md compiler

bash adapters/codex/install.sh

Compiles all active rules, skills, and command definitions into a standard AGENTS.md recognized by Aider, Cline, and Continue.

How CoCo Works

flowchart LR
  U["You<br/>(Slash command, plain English)"] --> AI["Your AI Harness<br/>(Claude Code, Cursor, Codex…)"]
  AI --> A["IDE Adapter"]
  A --> S["CoCo Assets<br/>skills · agents · commands · rules · personas"]
  S -. Read at runtime .-> AI
  AI --> Agents["Parallel Subagents<br/>(executed by your harness)"]
  Agents --> AI

Installation Matrix

Standard 90-second setup

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

The installer auto-detects your active IDE/CLI.

Via global npm package

# Authenticate the GitHub Packages registry
echo "@coco-research:registry=https://npm.pkg.github.com" >> ~/.npmrc
echo "//npm.pkg.github.com/:_authToken=YOUR_TOKEN" >> ~/.npmrc

# Install and launch
npm install -g cocosuperintelligence
coco

Activate orchestration bundles

# Enable GSD, Brain, and Team systems
bash install.sh --systems gsd,brain

# Enable the Super Intelligence board
bash install.sh --systems superintelligence

Manual adapter overrides

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

One-line remote install

bash <(curl -fsSL https://raw.githubusercontent.com/coco-research/coco/main/bin/coco-bootstrap.sh)

Clones Coco to ~/.coco, then pauses and prints the commit hash, date, and message so you can verify it against the latest commit on main before it runs install.sh. Type y to proceed. Pass --yes or set COCO_BOOTSTRAP_YES=1 to skip the prompt for CI or scripted installs, and pass adapter/systems flags after --, e.g. -- --adapter cursor --systems gsd.

The install paths above are deliberately conservative: the remote bootstrap never runs code before you have confirmed the commit it cloned, install.sh only ever reads and symlinks files already inside the repository, the CI workflows that build and publish Coco pin their setup-node and setup-python Actions to commit SHAs rather than mutable tags, and nothing Coco does locally or in CI sends data anywhere. See SECURITY.md for the full policy.

Staying Current

CoCo tells you when a newer version is available — it checks the GitHub repository at most once per day, prints a one-line banner, and sends no telemetry. Disable with COCO_NO_UPDATE_CHECK=1.

git clones

# print version + update status
bash scripts/check-update.sh

# apply an update
git pull --ff-only && bash install.sh

npm installs

# print version + check for updates
npx cocosuperintelligence version

# apply an update
npx cocosuperintelligence update

Releases are tracked in CHANGELOG.md and on the GitHub Releases page.

System Compatibility

Technical Specifications

Core install ships 68 skills + 37 commands + 10 agents + 15 rules (130 active assets). The totals above reflect a full install with every bundle (bash install.sh --systems gsd,brain,cognee,hyperframes,superintelligence). Super Intelligence slash commands are generated locally at install time from the team registries — no command files are transmitted or stored remotely.

Frequently Asked Questions

Contributing & Community

CoCo is open-core: the core is MIT-licensed and contributions are welcome. The Super Intelligence System (systems/superintelligence/) is proprietary — see systems/superintelligence/LICENSE.

Start here: CONTRIBUTING.md — how to add a skill, command, agent, or adapter.
Good first issues: help wanted / good first issue — small, well-scoped tasks for newcomers.
Report a bug / request a feature: open an issue.
Security: see SECURITY.md for responsible disclosure.
Conduct: see CODE_OF_CONDUCT.md.

Before opening a PR, validate locally — CI runs a frontmatter linter, manifest validation, and an install-script syntax check.

Built On

CoCo Super Intelligence stands on the shoulders of excellent open-source work. Special thanks to:

obra/superpowers (Jesse Vincent) — the foundational engineering-discipline skills (brainstorming, systematic debugging, TDD, plan writing/execution, git worktrees, code-review flows, verification, and skill authoring).
gsd-build/get-shit-done — the 68-skill / 24-agent GSD project-orchestration bundle.
heygen-com/hyperframes (HeyGen, Inc., Apache License 2.0) — the 20-skill HyperFrames video/motion bundle vendored under systems/hyperframes/ (composition engine, CLI, animation, creative direction, registry, and the video-authoring suite).
JCodesMore/ai-website-cloner-template — the site-cloning structure behind clone-website.
agents.md community — the vendor-neutral agent-context standard CoCo's adapters follow.
nickwinder/synthteam (Nick Winder) — the multi-agent debate protocol behind --debate deliberation.
latent-spaces/brag (Shunit Haviv) and HyperFrames (HeyGen) — the launch-video flow and local render engine behind coco-ads.
leonxlnx/taste-skill (Leon) — the design-taste enforcement behind design-taste-frontend and redesign-existing-projects.
HKUDS/CLI-Anything — the "wrap any CLI into a structured skill" methodology behind cli-anything.
Vercel and vercel-labs/web-interface-guidelines — the source material behind vercel-react-best-practices and web-design-guidelines.

Full attributions — including feature-level inspirations, bundled audio (ende.app, Kenney.nl), and licenses — live in CREDITS.md. If something influenced CoCo and isn't listed, that's a bug: open an issue.

File tree

1592

coco-research/cocoView on GitHub

.arch/
  ARCH-EVIDENCE.md
  index.json
  INDEX.md
  pinned-commit
.claude-plugin.json
.github/
  dependabot.yml
  FUNDING.yml
  ISSUE_TEMPLATE/
    bug_report.md
    feature_request.md
    good_first_issue.md
  PULL_REQUEST_TEMPLATE.md
  workflows/
    ci.yml
    lint-frontmatter.yml
    publish-npm.yml
    publish-npmjs.yml
.gitignore
.nojekyll
adapters/
  claude-code/
    install.sh
    manifest.json
    README.md
  codex/
    install.sh
    manifest.json
    README.md
  cursor/
    install.sh
    manifest.json
    README.md
    skills/
      create-rule/
        SKILL.md
      create-skill/
        SKILL.md
      create-subagent/
        SKILL.md
      migrate-to-skills/
        SKILL.md
      update-cursor-settings/
        SKILL.md
  generic/
    install.sh
    manifest.json
    README.md
  vscode-continue/
    install.sh
    manifest.json
    README.md
agents/
  ai-engineer.md
  code-reviewer.md
  data-specialist.md
  database-architect.md
  INDEX.md
  mcp-specialist.md
  pm-advisor.md
  README.md
  refactoring-specialist.md
  test-guardian.md
  typescript-pro.md
  ui-ux-designer.md
assets/
  demo.gif
  logo-light.png
  logo-light.svg
  logo-si-light.png
  logo-si-light.svg
  logo-si.png
  logo-si.svg
  logo.svg
  og-image.png
  og-image.svg
bin/
  coco-bootstrap.sh
  coco.js
CHANGELOG.md
CODE_OF_CONDUCT.md
commands/
  design/
    mermaid.md
  email/
    _index.md
    read.md
    reply.md
    save.md
    search.md
    summary.md
    thread.md
    today.md
    unread.md
  eng/
    anti-pattern.md
  INDEX.md
  pm/
    sync-init.md
  team/
    _index.md
    arch.md
    architecture.md
    communicate.md
    develop.md
    document.md
    evidence.md
    feedback.md
    fix.md
    plan.md
    present.md
    reanalyse.md
    research.md
    review.md
    roles.md
    scrape.md
    ship.md
    test.md
    think.md
    toolkit.md
    verify.md
  util/
    architecture-review.md
    create-architecture-documentation.md
    refactor-code.md
    ss.md
CONTRIBUTING.md
CREDITS.md
docs/
  architecture.md
  by-domain/
    design.md
    engineering.md
    foundational.md
    meta.md
    ops.md
    pm.md
  distribution/
    claude-code-marketplace.md
    cursor-extension.md
    npm-github-packages.md
  getting-started.md
  guides/
    comparison.md
    cookbook.md
    migration.md
  INDEX.md
  install.md
  recommended-plugins.md
  TROUBLESHOOTING.md
examples/
  agent-coordination-walkthrough.md
  sample-prd-api.md
  sample-prd.md
  sample-project-memory.md
  verification-failure-example.md
Formula/
  coco.rb
install.sh
LICENSE
package.json
README.md
rules/
  cursor-mdc/
    agents-md-creation.mdc
    code-quality.mdc
    dependency-management.mdc
    file-organization.mdc
    git-conventions.mdc
    parallel-agents.mdc
    persistent-memory.mdc
    prd-default-skill.mdc
    prd-management.mdc
    react-default-skills.mdc
    security-rules.mdc
    senior-architect.mdc
    skill-router.mdc
    testing-standards.mdc
    verification-workflow.mdc
  README.md
scripts/
  build-index.py
  check-update.sh
SECURITY.md
skills/
  agent-lightning/
    reference.md
    SKILL.md
  ai-marketing-videos/
    SKILL.md
  ai-product/
    SKILL.md
  api-design-principles/
    assets/
      api-design-checklist.md
      rest-api-template.py
    references/
      graphql-schema-design.md
      rest-best-practices.md
    SKILL.md
  arb-review/
    references/
      arb-format.md
    SKILL.md
  arch-index/
    references/
      analysis-taxonomy.md
      arch-plan.md
      component-rules.md
      schema.md
      tool-frugality.md
    scripts/
      arch_drift.py
      fixtures/
        bad-invariants.json
        bad-paths.json
        good.json
        plan-bad-shape.json
        plan-good.json
        plan-unbuilt.json
      repo_tree.py
      run_fixtures.sh
      validate_index.py
      verify_arch_plan.py
    SKILL.md
    templates/
      ARCH-EVIDENCE.md.template
      INDEX.md.template
  axiom-liquid-glass/
    SKILL.md
  brainstorming/
    scripts/
      frame-template.html
      helper.js
      server.js
      start-server.sh
      stop-server.sh
    SKILL.md
    spec-document-reviewer-prompt.md
    visual-companion.md
  browser-automation/
    SKILL.md
  c4-architecture/
    references/
      advanced-patterns.md
      c4-syntax.md
      common-mistakes.md
    SKILL.md
  change-log/
    SKILL.md
  cli-anything/
    SKILL.md
  clone-website/
    SKILL.md
  coco/
  coco-ads/
    assets/
      music/
        cues/
          happy-beats-business-moves-vol-1-by-ende-dot-app.music-cues.json
          happy-beats-business-moves-vol-1-by-ende-dot-app.music-cues.md
          happy-beats-business-moves-vol-10-by-ende-dot-app.music-cues.json
          happy-beats-business-moves-vol-10-by-ende-dot-app.music-cues.md
          happy-beats-business-moves-vol-11-by-ende-dot-app.music-cues.json
          happy-beats-business-moves-vol-11-by-ende-dot-app.music-cues.md
          happy-beats-business-moves-vol-12-by-ende-dot-app.music-cues.json
          happy-beats-business-moves-vol-12-by-ende-dot-app.music-cues.md
          happy-beats-business-moves-vol-9-by-ende-dot-app.music-cues.json
          happy-beats-business-moves-vol-9-by-ende-dot-app.music-cues.md
        happy-beats-business-moves-vol-1-by-ende-dot-app.mp3
        happy-beats-business-moves-vol-10-by-ende-dot-app.mp3
        happy-beats-business-moves-vol-11-by-ende-dot-app.mp3
        happy-beats-business-moves-vol-12-by-ende-dot-app.mp3
        happy-beats-business-moves-vol-9-by-ende-dot-app.mp3
        README.md
      sfx/
        casino/
          card-fan-1.ogg
          card-fan-2.ogg
          card-place-1.ogg
          card-place-2.ogg
          card-place-3.ogg
          card-place-4.ogg
          card-shove-1.ogg
          card-shove-2.ogg
          card-shove-3.ogg
          card-shove-4.ogg
          card-shuffle.ogg
          card-slide-1.ogg
          card-slide-2.ogg
          card-slide-3.ogg
          card-slide-4.ogg
          card-slide-5.ogg
          card-slide-6.ogg
          card-slide-7.ogg
          card-slide-8.ogg
          cards-pack-open-1.ogg
          cards-pack-open-2.ogg
          chip-lay-1.ogg
          chip-lay-2.ogg
          chip-lay-3.ogg
          chips-collide-1.ogg
          chips-collide-2.ogg
          chips-collide-3.ogg
          chips-collide-4.ogg
          chips-handle-1.ogg
          chips-handle-2.ogg
          chips-handle-3.ogg
          chips-handle-4.ogg
          chips-handle-6.ogg
          chips-stack-1.ogg
          chips-stack-2.ogg
          chips-stack-3.ogg
          chips-stack-4.ogg
          chips-stack-5.ogg
          chips-stack-6.ogg
          dice-grab-1.ogg
          dice-grab-2.ogg
          dice-shake-1.ogg
          dice-shake-2.ogg
          dice-shake-3.ogg
          dice-throw-1.ogg
          dice-throw-2.ogg
          dice-throw-3.ogg
          die-throw-1.ogg
          die-throw-2.ogg
          die-throw-3.ogg
          die-throw-4.ogg
        impact/
          footstep_carpet_000.ogg
          footstep_carpet_003.ogg
          footstep_carpet_004.ogg
          footstep_concrete_000.ogg
          footstep_concrete_001.ogg
          footstep_concrete_002.ogg
          footstep_concrete_003.ogg
          footstep_concrete_004.ogg
          footstep_grass_000.ogg
          footstep_grass_001.ogg
          footstep_grass_002.ogg
          footstep_grass_003.ogg
          footstep_grass_004.ogg
          footstep_snow_000.ogg
          footstep_snow_001.ogg
          footstep_snow_002.ogg
          footstep_snow_003.ogg
          footstep_snow_004.ogg
          footstep_wood_000.ogg
          footstep_wood_001.ogg
          footstep_wood_002.ogg
          footstep_wood_003.ogg
          footstep_wood_004.ogg
          impactBell_heavy_000.ogg
          impactBell_heavy_003.ogg
          impactBell_heavy_004.ogg
          impactGeneric_light_000.ogg
          impactGeneric_light_001.ogg
          impactGeneric_light_002.ogg
          impactGeneric_light_003.ogg
          impactGeneric_light_004.ogg
          impactGlass_heavy_002.ogg
          impactGlass_light_001.ogg
          impactGlass_light_002.ogg
          impactGlass_light_003.ogg
          impactGlass_medium_000.ogg
          impactGlass_medium_002.ogg
          impactGlass_medium_004.ogg
          impactMetal_heavy_000.ogg
          impactMetal_heavy_002.ogg
          impactMetal_heavy_004.ogg
          impactMetal_light_002.ogg
          impactMetal_light_003.ogg
          impactMetal_medium_000.ogg
          impactMetal_medium_001.ogg
          impactMetal_medium_002.ogg
          impactMetal_medium_003.ogg
          impactMetal_medium_004.ogg
          impactMining_001.ogg
          impactPlank_medium_000.ogg
          impactPlank_medium_001.ogg
          impactPlank_medium_002.ogg
          impactPlank_medium_003.ogg
          impactPlank_medium_004.ogg
          impactPlate_heavy_000.ogg
          impactPlate_heavy_001.ogg
          impactPlate_heavy_002.ogg
          impactPlate_heavy_003.ogg
          impactPlate_heavy_004.ogg
          impactPlate_light_000.ogg
          impactPlate_light_001.ogg
          impactPlate_light_002.ogg
          impactPlate_light_003.ogg
          impactPlate_light_004.ogg
          impactPlate_medium_000.ogg
          impactPlate_medium_001.ogg
          impactPlate_medium_002.ogg
          impactPlate_medium_003.ogg
          impactPlate_medium_004.ogg
          impactPunch_heavy_000.ogg
... 1600 more

Showing a partial view of a very large repo.

FAQ

coco is a Claude Code plugin with 174 hand-picked skills for development work, indexed on Flowy. Install it with the command on its page. It includes create-rule, create-skill, create-subagent. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.

What is coco?: Meet Coco. A superintelligent agent framework powered by an advisory board of 389 world-class minds. Scale your AI assistant into a complete engineering department with 142 skills, 277 commands, and persistent state. Universal compatibility. Local privacy. Free and open source.
How do I install coco?: Run these in Claude Code: npx -y skills add coco-research/coco --agent claude-code. Then prompt normally.
Does coco auto-invoke its skills?: Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
Is coco free?: Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.