Claude Copilot

What Is Claude Copilot?

Claude Copilot is a set of instructions that sit on top of Claude Code. This is an independent, community-driven framework for Claude Code, unaffiliated with Microsoft Copilot or GitHub Copilot.

It's not separate software—it's markdown files (agents, commands, project instructions) and two CLI tools (cc and tc) that give Claude Code new capabilities:

When Claude Code reads these instructions, it gains persistent memory, 15 framework agents (plus kc, setup-only), and a structured process — the design goal being more disciplined, resumable work built from the practices that tend to produce better software. We measure process and context efficiency, not output quality; there is no defect/rework data yet.

→ Why we built this

The Problem

Solo developers are expected to be experts in everything. AI assistants help, but they:

• Forget everything between sessions
• Give generic advice without context
• Lack proven processes for complex work

Teams face the same challenges at scale—plus knowledge silos, inconsistent standards, and AI that amplifies inconsistency.

→ Read the full problem statement

April 2026 Restructure

A diagnostic of 15 sessions (Apr 17-22 2026) found a 6% delegation rate — 94% of work stayed in the main session despite a 14-agent roster. A 5-day staging deployment saga (57 manual bash polling calls, 26 loops) exposed missing primitives. The April 2026 restructure introduced mechanical hook enforcement, the tc deploy wait primitive, and model pinning. The roster was consolidated to 8 agents as an interim step to reduce complexity during the hook rollout; it has since been restored and expanded to the current 15 framework agents + kc (setup-only) as the enforcement layer proved stable.

→ Full diagnostic and rationale

How It Works

┌─────────────────────────────────────────────────────────────────────────────┐
│                              YOU                                             │
│                               │                                              │
│                    "Fix the login bug" or "/continue"                        │
└───────────────────────────────┼─────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                         PROTOCOL LAYER                                       │
│                                                                              │
│   /protocol  →  Classifies request, routes to right agent                   │
│   /continue  →  Loads your previous session from memory                     │
└───────────────────────────────┼─────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                          AGENT LAYER                                         │
│                                                                              │
│   ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐  │
│   │   ta    │ │   me    │ │   qa    │ │   doc   │ │   do    │ │   sd    │  │
│   │Architect│ │Engineer │ │   QA    │ │  Docs   │ │ DevOps  │ │ Service │  │
│   │         │ │         │ │         │ │         │ │         │ │Designer │  │
│   └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘  │
│   ┌─────────┐ ┌─────────┐ ┌─────────┐  ┌─────────┐                          │
│   │   uxd   │ │  uids   │ │   uid   │  │   kc    │  Knowledge Copilot       │
│   │UX Design│ │UI Design│ │UI Dev   │  │ (util)  │                          │
│   │         │ │ System  │ │         │  └─────────┘                          │
│   └─────────┘ └─────────┘ └─────────┘                                      │
└───────────────────────────────┼─────────────────────────────────────────────┘
                                │
              ┌─────────────────┼─────────────────┐
              │                 │                 │
              ▼                 ▼                 ▼
┌────────────────────┐ ┌────────────────────┐ ┌────────────────────────────────┐
│   MEMORY COPILOT   │ │   TASK COPILOT     │ │          cc SKILLS             │
│   (cc memory)      │ │   (tc CLI)         │ │                                │
│ • Decisions made   │ │ • PRDs & tasks     │ │ • Auto-fires from description  │
│ • Lessons learned  │ │ • Work products    │ │ • Code-bearing: L1/L2/L3      │
│ • FTS5 keyword     │ │ • ~94% less context│ │ • Known References registry    │
│                    │ │   for externalized │ │   (configured paths/refs only) │
│                    │ │   work products vs │ │ • Agent auto-pull: roadmap     │
│                    │ │   inlining outputs │ │                                │
│ • Enables /continue│ │ • tc.api facade    │ │ • cc.api facade                │
└────────────────────┘ └────────────────────┘ └────────────────────────────────┘

Quick Start

1. Clone

mkdir -p ~/.claude && cd ~/.claude
git clone https://github.com/Everyone-Needs-A-Copilot/claude-copilot.git copilot

2. Machine Setup (once)

cd ~/.claude/copilot && claude

Then say:

Read @SETUP.md and set up Claude Copilot on this machine

3. Project Setup (each project)

cd ~/your-project && claude

Then run:

/setup-project

4. Start Working

/protocol fix the login bug          # Start fresh work
/continue                            # Resume where you left off

→ Complete setup guide

How to Use This Framework

Two patterns cover most development work:

Pattern 1: Fix a Bug

Illustrative (not a captured transcript).

/protocol the checkout form submits twice on Enter key

What happens step-by-step:

1. Protocol classifies your request:

   [PROTOCOL: DEFECT | Agent: @agent-qa | Action: INVOKING]
   Detected: Bug fix → Routing to QA Engineer...
   

2. @agent-qa diagnoses:

   Bug reproduced. Root cause: Missing preventDefault() on keyDown handler.
   Routing to @agent-me for fix...
   

3. @agent-me implements:

   Fix implemented:
   - Added e.preventDefault() to handleKeyDown
   - Added test: "prevents double submission on Enter"
   
   Routing back to @agent-qa for verification...
   

4. @agent-qa verifies and commits:

   Verification: PASS ✓
   Git commit: fix(TASK-abc): Prevent double submission on Enter key
   

Pattern 2: Build a Feature (with Orchestration)

For substantial features, use parallel work streams:

/protocol ultrawork add OAuth authentication with Google and GitHub

Step 1: Planning

The Tech Architect creates a plan with parallel streams:

✓ PRD Created: PRD-xyz789
✓ 4 streams identified with 18 tasks

Stream Structure:
  Depth 0 (Foundation):
    • Stream-A (Database & Config) - 4 tasks

  Depth 1 (Parallel):
    • Stream-B (Google OAuth) - 5 tasks → depends on: Stream-A
    • Stream-C (GitHub OAuth) - 5 tasks → depends on: Stream-A

  Depth 2 (Integration):
    • Stream-Z (Integration & Docs) - 4 tasks → depends on: Stream-B, Stream-C

Next: Run /orchestrate start to begin parallel execution

Step 2: Set up worktrees and launch agents

/orchestrate start

Scaffolding ready. Each stream has an isolated worktree.

Launching Task agents for each stream...
  Stream-A (Foundation)... ✓ Agent launched
  Stream-B (blocked by Stream-A) - will start when ready
  Stream-C (blocked by Stream-A) - will start when ready
  Stream-Z (blocked by Stream-B, Stream-C) - will start when ready

Step 3: Monitor progress

/orchestrate status

Stream     | Status      | Progress
-----------|-------------|----------
Stream-A   | completed   | 100%
Stream-B   | in_progress | 60%
Stream-C   | in_progress | 40%
Stream-Z   | pending     | 0%

Step 4: Completion

When all streams finish:

🎉 INITIATIVE COMPLETE 🎉

All streams completed. 18 git commits created.

Quick Commands

Work Intensity Keywords

→ Full usage guide with more scenarios

(Optional) Shared Knowledge

/knowledge-copilot

Creates a Git-managed knowledge repository for company information, shareable via GitHub

Your Team

Core agents (always available):

Design chain (sd → uxd → uids → uid → ta → me):

Specialist branches:

Business advisory (optional — outside the software build chain):

cs and cpa are standalone advisory agents for founder/agency business needs. They do not route into the build chain (sd → uxd → uids → uid → ta → me). Invoke them directly.

→ Meet your full team | Agent roster history

All Commands

→ Orchestration Guide | Knowledge Sync

Works Alone, Grows With Teams

→ Customization guide | Extension Spec

Requirements

Build tools (for Python packages):

• macOS: xcode-select --install
• Linux: sudo apt-get install build-essential

Documentation

Start here:

Setup & Configuration:

Advanced:

Operations:

Reference:

Contributing

Contributions welcome! See CONTRIBUTING.md.

When modifying agents:

• Keep base agents generic (no company-specific content)
• Use industry-standard methodologies
• Include routing to other agents

License

MIT License - see LICENSE

Acknowledgements

This project builds on the work of many contributors and open source projects. See ACKNOWLEDGEMENTS.md for credits.