A self-evolving expert-team framework you add to Claude.
Compass is a Claude Agent Skill. Once it's active, Claude stops behaving like a single assistant and starts running a small expert team on top of whatever you're building — led by a permanent Project Manager, backed by specialist personas generated for your project. The team audits what it doesn't know, teaches itself with real research, flags when it's missing a tool, and keeps getting sharper as the work gets harder.
It works in Claude Code and on claude.ai.
When you activate Compass and describe a project, it:
- Restates the project and what "done" looks like, so you're aligned before anything starts.
- Assembles a team — a permanent Project Manager plus 2–4 named specialists, each with a domain and a "lens" (the angle it views every decision through), and tells you why each seat exists.
- Audits its own gaps — each specialist names what it actually doesn't know yet.
- Teaches itself — the specialists research their gaps with real lookups (not guessing), capped at 3 rounds so it never spins forever.
- Checkpoints with you — presents what it learned and the decisions that are genuinely yours, then stops and waits instead of barreling ahead.
- Builds — and along the way, whenever it hits a wall, it diagnoses whether the blocker is a knowledge gap (research it), a skill gap (build it), or a connector gap (recommend the tool).
The Project Manager leads as a player-coach, not a boss: it proposes the next move, checks it with the team, and only then commits.
Drop it onto a project that already has its own persona team and it joins as an advisor by default — it keeps your existing people, suggests additions, and asks whether you want it purely advisory or leading, rather than steamrolling what you built.
A real run, sped up ~4×: one prompt → team assembled → specialists research in parallel → honest checkpoint before building.
Here's that same run, step by step. The whole prompt was one line:
You: Activate Compass. I want to build a small web app that helps home cooks plan a week of meals from ingredients they already have and generates a grocery list for whatever's missing.
Compass assembled a team and put each specialist's lens on the table:
| Seat | Persona | Domain & lens |
|---|---|---|
| PM | Mesa | Drives the loop. "What's the next thing that actually gets a cook to a grocery list?" |
| 1 | Juniper | Recipe data. "Can we get clean, matchable ingredient data cheaply?" |
| 2 | Nori | Matching & meal-planning logic. "Does this correctly tell the cook what they can make and what to buy?" |
| 3 | Wren | Frontend / UX. "Is this fast and pleasant for a tired cook on a phone?" |
Then the specialists researched their real gaps in parallel — and came back with specifics, not guesses:
Juniper (recipe data): The APIs are all compromised for this use case — Spoonacular caps the free tier at 150 requests/day and forbids caching over an hour; Edamam bans caching entirely (fatal for a pantry-matching app). Recommendation: bundle ~50–200 recipes as local JSON, normalized once from TheMealDB (which is cacheable), behind an adapter so we can swap in a live API later. Zero rate limits, works offline, ships fast.
Nori (matching engine): Use the
parse-ingredientlibrary to split "2 ripe roma tomatoes, diced" into quantity/unit/name, then match on presence/absence ("do you have tomato at all?") rather than brittle unit math. Assumed staples (salt, oil, water) stay off the grocery list. Each recipe scores by the fraction of ingredients you already own — so the week ranks itself from least-shopping to most.
Finally it stopped at a checkpoint and handed back the decisions that were genuinely the user's — each with a recommendation, none decided unilaterally:
Three things I won't decide for you:
- Where should the recipes come from for the MVP? → Bundled local JSON (recommended)
- What should a "week of meals" cover? → 7 dinners (recommended)
- What should the app be built with? → React + Vite + Tailwind (recommended)
No wall of text on a bare "Activate Compass," real research instead of hand-waving, and a genuine stop-and-ask before building — that's the whole point.
Option A — clone the folder (recommended):
git clone https://github.com/chrisjay629/compass.git
cp -R compass/compass ~/.claude/skills/compassThat leaves you with ~/.claude/skills/compass/SKILL.md. It's active in your next session.
Option B — grab the packaged file:
Download dist/compass.skill, unzip it into ~/.claude/skills/ so you end up with ~/.claude/skills/compass/SKILL.md.
(For a single project instead of globally, use .claude/skills/compass/ inside the project.)
Requires a plan with code execution enabled (Pro, Max, Team, or Enterprise).
- Download
dist/compass-claude-ai.zip. - In claude.ai, go to Settings → Capabilities and make sure code execution is on.
- Go to Settings → Skills → Create skill and upload the zip.
- Toggle it on.
(Custom skills on claude.ai are per-user — each person uploads their own copy.)
In any chat where the skill is installed, just say:
Activate Compass
Compass will greet you and ask what you're working on. Or describe the project in the same message and it goes straight to work:
Activate Compass. I want to build a web app that plans a week of meals
from ingredients I already have and generates a grocery list.
You don't always have to say the words — if you ask for "a team of specialists" or "experts on this project," Claude will often reach for Compass on its own. But saying "Activate Compass" is the guaranteed switch.
Tip for claude.ai: start the project inside a Project (not a one-off chat) if you want the team's memory (COMPASS.md) to survive across conversations — a plain chat's files are ephemeral.
- It's a behavioral framework, not an app. Compass steers how Claude works; it doesn't install software or run a server.
- It recommends real connectors, but can't connect them for you. It suggests which Claude Connectors would help and what each unlocks — you add them on your side.
- It keeps a memory file. Compass writes a
COMPASS.mdat your project root to remember the team, what they've learned, and where things stand across sessions. - Surfaces differ. It adapts between Claude Code and claude.ai (filesystem persistence, which tools exist, whether web research is available) and tells you honestly when a surface can't do something rather than faking it.
Skills give Claude new instructions and can run code, so only install skills from sources you trust. This one is plain Markdown you can read end-to-end in compass/SKILL.md — no scripts, no network calls. Give it a read before you install it.
MIT — do what you like with it.