Explore Codebase
Orient an agent on an unfamiliar repo using code-review-graph MCP before review, debug, or refactor with a strict minimal-context token budget.
Overview
Explore Codebase is an agent skill most often used in Ship (also Build integrations, Operate errors) that walks agents through code-review-graph MCP tools to map architecture and flows under a ≤5-call, ≤800-token budget.
Install
npx skills add https://github.com/tirth8205/code-review-graph --skill explore-codebaseWhat is this skill?
- Six-step exploration flow: stats, architecture, communities, semantic search, query_graph, flows
- Mandates get_minimal_context before any other graph tool call
- detail_level minimal by default with standard only when needed
- Target budget: complete review/debug/refactor in ≤5 tool calls and ≤800 output tokens
- Relationship patterns: callers_of, callees_of, imports_of, children_of, find_large_functions
- ≤5 tool calls target for review/debug/refactor orientation
- ≤800 total output tokens target
- 6 numbered exploration steps in the workflow
Adoption & trust: 722 installs on skills.sh; 18.2k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your coding agent wastes context reading entire trees when you need fast architectural orientation and relationship tracing for review or debug.
Who is it for?
Solo developers using code-review-graph MCP who want repeatable, token-cheap codebase exploration before review or incident triage.
Skip if: Repos without the graph MCP indexed, greenfield projects with no code to graph, or tasks that only need stylistic lint fixes.
When should I use this skill?
Navigate and understand codebase structure using the knowledge graph before review, debug, or refactor.
What do I get? / Deliverables
You get a minimal-context graph map—stats, communities, flows, and symbol links—ready for deeper review or a focused refactor plan.
- Architecture and community overview from graph stats
- Traced relationships and execution flows for the stated task
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
The workflow first appears when you need structured codebase understanding immediately before ship-phase review, though the same graph passes support build and operate debugging. Review is the canonical shelf because the skill explicitly targets review, debug, and refactor tasks with graph tools and caller/callee tracing.
Where it fits
Run list_graph_stats and get_architecture_overview before drafting PR review comments on an unfamiliar service.
Use imports_of and get_flow to see how a new webhook handler connects to existing modules.
Trace callers_of a failing function and list_flows to narrow a production regression.
Semantic_search_nodes to locate auth middleware then children_of the file for class-level entry points.
How it compares
Use as a graph-MCP workflow instead of ad-hoc read_file sweeps that blow the context window before any review comment.
Common Questions / FAQ
Who is explore codebase for?
Builders and reviewers who already use the code-review-graph MCP and want a fixed playbook so agents explore repos efficiently.
When should I use explore codebase?
In ship review before commenting on a PR; in build when tracing integrations across modules; in operate when debugging failures and you need callers, callees, and execution flows quickly.
Is explore codebase safe to install?
The skill instructs graph queries only; confirm MCP server trust and review the Security Audits panel on this Prism page before install.
SKILL.md
READMESKILL.md - Explore Codebase
## Explore Codebase Use the code-review-graph MCP tools to explore and understand the codebase. ### Steps 1. Run `list_graph_stats` to see overall codebase metrics. 2. Run `get_architecture_overview` for high-level community structure. 3. Use `list_communities` to find major modules, then `get_community` for details. 4. Use `semantic_search_nodes` to find specific functions or classes. 5. Use `query_graph` with patterns like `callers_of`, `callees_of`, `imports_of` to trace relationships. 6. Use `list_flows` and `get_flow` to understand execution paths. ### Tips - Start broad (stats, architecture) then narrow down to specific areas. - Use `children_of` on a file to see all its functions and classes. - Use `find_large_functions` to identify complex code. ## Token Efficiency Rules - ALWAYS start with `get_minimal_context(task="<your task>")` before any other graph tool. - Use `detail_level="minimal"` on all calls. Only escalate to "standard" when minimal is insufficient. - Target: complete any review/debug/refactor task in ≤5 tool calls and ≤800 total output tokens.