Claude Code Setup Series — Guide 5 of 5 (Capstone)

Choose the right agent repos for the moment you are in

You have installed Claude Code, organized your workspace, and connected your MCP servers. Now: which GitHub repos and skills should you actually install — and which ones should you leave alone until you need them.

Where this fits in the series

Guides 1 through 4 covered the foundations: why AI coding tools are developer infrastructure, not just autocomplete; how to set up a new machine cleanly; how to structure your workspace with seven folders and a CLAUDE.md file; and how to connect Composio MCP servers so agents can reach external tools.

This capstone has a different job. Now that the infrastructure exists, you need to make a judgment call: which community-built repos, skills, and agent frameworks are worth installing today, and which ones will add complexity before they add value? The answer depends almost entirely on what you are trying to do right now — not on your general skill level, and not on which repos have the most GitHub stars.

The pattern that breaks most setups is installing too much too early. A catalog of fifty skills sitting in your global config before you have shipped a single feature is not a superpower — it is noise. This guide is structured around a single question: what stage are you at?

1. Why infrastructure
2. New machine setup
3. Workspace structure
4. Composio MCP
5. Repo advisor (you are here)

What is a repo and how do you install one?

A repository (repo) is a folder of code files hosted on GitHub. When people say "install a repo," they mean: download it to your machine, then tell Claude Code where it lives or configure it as a plugin, MCP server, or skills directory.

Method 1 — Automated (recommended) Use the copy-paste prompt at the bottom of this page. Paste it into Claude Code and describe what you are building. Claude Code will inspect your project, recommend specific repos, and install them with your approval. You stay in control; you do not need to know the commands.

Method 2 — Manual (when you want to understand what happens)

Click the repo link to open GitHub
Click the green Code button and copy the URL
In your terminal: git clone [URL]
Tell Claude Code the path: "I have repo [name] at [path]"

Before you install anything, check four things:

README Does it explain what problem it solves? If you cannot find your workflow in the first paragraph, skip it.

Last update Repos that have not been touched in 12+ months may not work with current Claude Code versions.

Issue count Many open issues about installation failures or missing features is a yellow flag. Read a few before committing.

License For commercial projects, confirm the license allows your use case. MIT is fine; some are not.

1 Start small, not comprehensive

Install workflow guardrails before you install catalogs, memory systems, browser automation, or full agent platforms. The first question is always: do I have a clear, repeatable workflow? If not, more tools will not help. A single repo like superpowers that gives you structure for planning, testing, and finishing branches will unlock more value than a catalog of fifty skills you do not have a home for.

Do: one workflow tool that fits your current task
Do not: bulk-install a catalog before your first feature ships

2 Global vs project scope — be deliberate

Global install means the tool is available in every project on your machine. Project install means it lives in .claude/ inside one repo. The decision rule: install globally only what you would use in almost every project. Install at project level anything domain-specific. Use read-only reference for everything else — read the README, copy one pattern if useful, move on.

Global examples: superpowers, universal TDD/review hooks
Project examples: react-doctor, trailofbits security skills, project MCP
Reference only: full catalogs, memory systems (until you genuinely need them)

3 Verify every workflow

Every task completed by an agent should end with a concrete verification step. "It looks right to me" is not verification. Before marking any agent task done, pick one: run the tests, take a screenshot of the running feature, review the PR summary Claude produces, or write down the known risks explicitly. This applies whether you are using a single skill or a five-agent pipeline. No verification step, no done.

Code change: run tests or build, confirm no new failures
UI feature: screenshot the actual browser state
Data or API: inspect one real output, not just the prompt response
Risky operation: write a short risk list, then proceed

Match repo to stage, not skill level

The most common mistake is choosing repos based on experience level. An advanced developer does not need all the advanced repos; a beginner should not be locked out of useful mid-project tools. What matters is where you are in the work right now.

Stage	What is happening	What to install	What to ignore
New machine	No projects yet. Setting up the base environment.	superpowers, anthropics/skills (as reference)	Everything else. Seriously.
New project	Starting work from a PRD or spec. First code commit imminent.	superpowers, 1–2 role-specific skills from agent-skills or subagents	Memory, browser automation, full platforms
Mid-project	Features exist. Bugs, quality, and performance are the current concern.	react-doctor (if React), promptfoo (if AI outputs need stability), security skills (if heading toward launch)	Memory systems, agent platforms
Advanced / agent product	The product itself includes agents, or you are building AI infrastructure.	promptfoo for evals, agentmemory or cognee if agents need state, VoltAgent or OpenHands for orchestration	Nothing is off-limits, but start in a sandbox

Pick your current stage and look only at that row. Return to the other rows when your situation changes.

Repo catalog

Use the stage buttons above or the advisor panel to filter. Memory repos appear only in the Advanced stage — they are not relevant until your agents genuinely need persistent state across sessions.

Copy-paste prompt for Claude Code

Paste this prompt into Claude Code to get a tailored install plan based on your current project and situation. Fill in the bracketed parts before sending.

I already have Claude Code installed and my workspace set up.
Help me choose the smallest useful agent repo setup for my current situation.

My situation: [describe what you are building or what problem you are solving]
My technical comfort: [beginner / comfortable with terminal / advanced]
Current stage: [new machine / new project / mid-project / building an AI product]

Please inspect my project context, then tell me:
1. Which workflow stage I am in (and whether my self-assessment matches)
2. Which repos or skills are worth installing right now
3. Which ones I should skip for now and why
4. For each recommendation: should it be global or project-level, and why
5. How we will verify each part of the setup after installation

Do not install anything before explaining the reason and asking for my approval.
Flag any repo that may conflict with existing tools in my setup.

Glossary

Terms that appear in this guide and in repo READMEs. Inline definitions are used throughout; this section collects them for quick reference.

TDD (Test-Driven Development) — Write automated tests before writing the code that makes them pass. Repos like superpowers build this pattern into the agent workflow so it happens by default.

Hooks — Code that runs automatically before or after a specific event. In Claude Code, hooks can fire before a file is saved, before a commit, or after a tool call. They enforce rules without requiring you to remember to apply them.

Evals (Evaluations) — Automated tests for AI output quality. Where unit tests check whether code runs correctly, evals check whether an LLM response meets a quality bar. promptfoo is the primary eval tool in this catalog.

Sandbox — An isolated environment where Claude Code runs without affecting your real files or systems. Use sandbox mode when evaluating unfamiliar repos or running destructive operations for the first time.

Subagent — A specialized Claude Code agent configured for one specific role (e.g., "security reviewer," "documentation writer"). Subagents receive a job and return a result, rather than owning the whole project.

MCP (Model Context Protocol) — The standard that lets Claude Code connect to external tools: databases, APIs, browsers, file systems, calendars, and more. MCP servers were covered in Guide 4.

Skill / Plugin — A packaged instruction set that Claude Code loads to gain a capability. Skills are scoped (global or project-level) and can be installed, removed, or referenced without installing.

Workflow — A repeatable sequence of agent actions: plan, code, test, review, verify, ship. Good workflow repos give the agent the same structure a senior engineer would follow habitually.

Next: install safely with the onboarding wizard

You have decided which repos fit your stage. The next step is installing them in a way that does not break your existing setup, respects the global-vs-project scope rule, and confirms each piece works before moving to the next.

agent-onboarding-wizard skill

The natural next action. This skill walks you through safe installation: it checks whether each repo belongs globally or at project level, asks the right questions before approving changes, and runs a verification step after each install. Start it by typing /agent-onboarding-wizard in Claude Code after your current session.

new-project-from-prd skill (optional)

If evaluating these repos has made you realize you want to start a new project from scratch — rather than continue with an existing one — the /new-project-from-prd skill scaffolds a full project from a product requirements document, using the workspace structure from Guide 3 as the base.

Back to guides