How Does This Work Explainer
cursor/plugins
Answers how-does-this-work and where-should-this-live questions by exploring the codebase with read-only subagents and writing an onboarding-depth explanation.
Answers where and how questions about a codebase with parallel research agents and a write-up where every claim cites a file and line, describing only what exists.
$ npx skills add Wirasm/prp --skill prp-codebase-question -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install Wirasm/prp prp-codebase-question --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/Wirasm/prp.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/prp-codebase-question .claude/skills/prp-codebase-question && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "prp-codebase-question" agent skill from https://github.com/Wirasm/prp/tree/development/.agents/skills/prp-codebase-question into .claude/skills/prp-codebase-question/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "prp-codebase-question", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/Wirasm/prp/tree/development/.agents/skills/prp-codebase-questionType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add Wirasm/prp --skill prp-codebase-question -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install Wirasm/prp prp-codebase-question --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Wirasm/prp.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.agents/skills/prp-codebase-question .agents/skills/prp-codebase-question && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "prp-codebase-question" agent skill from https://github.com/Wirasm/prp/tree/development/.agents/skills/prp-codebase-question into .agents/skills/prp-codebase-question/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "prp-codebase-question", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add Wirasm/prp --skill prp-codebase-question -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install Wirasm/prp prp-codebase-question --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Wirasm/prp.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.agents/skills/prp-codebase-question .cursor/skills/prp-codebase-question && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "prp-codebase-question" agent skill from https://github.com/Wirasm/prp/tree/development/.agents/skills/prp-codebase-question into .cursor/skills/prp-codebase-question/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "prp-codebase-question", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/Wirasm/prp.git --path .agents/skills/prp-codebase-question--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add Wirasm/prp --skill prp-codebase-question -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install Wirasm/prp prp-codebase-question --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Wirasm/prp.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.agents/skills/prp-codebase-question .gemini/skills/prp-codebase-question && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "prp-codebase-question" agent skill from https://github.com/Wirasm/prp/tree/development/.agents/skills/prp-codebase-question into .gemini/skills/prp-codebase-question/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "prp-codebase-question", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install Wirasm/prp prp-codebase-questionInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add Wirasm/prp --skill prp-codebase-question -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/Wirasm/prp.git skills-src && mkdir -p .github/skills && cp -r skills-src/.agents/skills/prp-codebase-question .github/skills/prp-codebase-question && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "prp-codebase-question" agent skill from https://github.com/Wirasm/prp/tree/development/.agents/skills/prp-codebase-question into .github/skills/prp-codebase-question/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "prp-codebase-question", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add Wirasm/prp --skill prp-codebase-question -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install Wirasm/prp prp-codebase-question --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Wirasm/prp.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.agents/skills/prp-codebase-question .opencode/skills/prp-codebase-question && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "prp-codebase-question" agent skill from https://github.com/Wirasm/prp/tree/development/.agents/skills/prp-codebase-question into .opencode/skills/prp-codebase-question/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "prp-codebase-question", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
prp-codebase-questionAnswers where and how questions about a codebase with parallel research agents and a write-up where every claim cites a file and line, describing only what exists.
The agent plays technical cartographer. It reads any files you mention in full, classifies the question as where, how, what, pattern or external, and splits it into two to five research areas. Parallel agents then investigate: a codebase-explorer to locate code and conventions, a codebase-analyst to trace how things flow, and a web-researcher when outside documentation matters. The findings are merged into a research document.
Its governing rule is to document what is, not what should be. Every claim needs a `file:line` reference, and the agent must not suggest improvements, critique implementations, run root cause analysis unless asked, or recommend refactoring. The `--web` flag adds external research and `--follow-up` appends to an existing research document. The excerpt is cut off before the output format.
6 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit 4352925. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Shell commands in SKILL.md call:
gitghFrom the folder's file list and the shell code blocks in SKILL.md.
Hosts in commands or code, which the agent is likely to contact:
github.comFrom URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Codebase Research Questions loads about 2.8k tokens when it runs. Until then it costs about 56 tokens; SKILL.md has 788 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from Wirasm/prp at commit 4352925, republished under its MIT licence (© Wirasm). 788 words, ~2,793 tokens.
.claude/skills/prp-codebase-question/SKILL.md (or your agent's skills folder).Arguments:
$ARGUMENTS(and$1,$2, ...) refer to the arguments given when this skill was invoked. Take them from the user's request; if absent, infer them from the conversation.
Input: $ARGUMENTS
Answer codebase questions thoroughly by spawning parallel specialized agents, synthesizing their findings, and producing a research document.
Core Philosophy: Document what IS, not what SHOULD BE. You are a technical cartographer.
Golden Rule: Every claim must have a file:line reference. No speculation, no suggestions, no critique.
If the user mentions specific files, read them FULLY first (no limit/offset) before any decomposition.
| Type | Indicators | Agent Focus |
|---|---|---|
| Where | "where is", "find", "locate" | codebase-explorer primary |
| How | "how does", "trace", "flow" | codebase-analyst primary |
| What | "what is", "explain", "describe" | Both agents in parallel |
| Pattern | "how do we", "convention", "examples" | codebase-explorer primary |
| External | "docs", "best practice", "API" | Add web-researcher |
--web flag for external research--follow-up flag for appending to existing researchPHASE_1_CHECKPOINT:
Break the query into 2-5 composable research areas:
RESEARCH QUESTION: {user's question}
AREAS:
1. {Area} → Agent: {which agent}
2. {Area} → Agent: {which agent}
3. {Area} → Agent: {which agent}| Agent | Use When |
|---|---|
codebase-explorer | Finding WHERE code lives, locating files, extracting patterns, discovering conventions |
codebase-analyst | Understanding HOW code works, tracing data flow, mapping integration points |
web-researcher | Only when --web flag is set or user explicitly asks for external docs |
Strategy:
codebase-explorer to find what existscodebase-analyst on the most relevant findings to trace how they workPHASE_2_CHECKPOINT:
Launch agents in parallel by spawning them as subagents in one step.
For each research area, use the appropriate agent:
codebase-explorer:
Find all code relevant to: {research area}
LOCATE:
1. {Specific files/components to find}
2. {Patterns or conventions to extract}
3. {Related test files and configuration}
Categorize findings by purpose. Return ACTUAL code snippets with file:line references.
Remember: Document what exists, no suggestions or improvements.codebase-analyst:
Analyze the implementation of: {research area}
TRACE:
1. {Data flow to trace}
2. {Integration points to document}
3. {Contracts between components}
Document what exists with precise file:line references. No suggestions.web-researcher:
Research external documentation for: {topic}
FIND:
1. {Specific documentation needed}
2. {API references or patterns}
Return findings with direct links and citations.IMPORTANT: Wait for ALL agents to complete before proceeding.
PHASE_3_CHECKPOINT:
file:line references throughoutMap findings back to the user's original question:
| Question Aspect | Finding | Evidence |
|---|---|---|
| {aspect 1} | {what was found} | file.ts:123 |
| {aspect 2} | {what was found} | file.ts:456 |
Note any areas that couldn't be fully documented:
PHASE_4_CHECKPOINT:
date -u +"%Y-%m-%dT%H:%M:%SZ"
git rev-parse --short HEAD
git branch --show-current
basename $(git rev-parse --show-toplevel)# --- PRP store resolver (canonical; keep byte-identical across skills) ---
# Adopt the store that already records this root; mint a key only when none does.
_gd="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"
case "$_gd" in */.git) _root="${_gd%/.git}" ;; "") _root="$PWD" ;; *) _root="$_gd" ;; esac
_root="$(cd "$_root" && pwd -P)"
_name="$(basename "$_root" | tr '[:upper:]' '[:lower:]' | tr -cs 'a-z0-9' '-' | sed 's/^-*//;s/-*$//')"
_home="${PRP_HOME:-$HOME/.prp}"
_hit="$(grep -lsF "\"path\": \"$_root\"" "$_home"/*/project.json 2>/dev/null | head -1)"
PRP_DIR="${_hit%/project.json}"
[ -n "$PRP_DIR" ] || PRP_DIR="$_home/${_name:-project}-$(printf %s "$_root" | git hash-object --stdin | cut -c1-8)"
mkdir -p "$PRP_DIR"; [ -f "$PRP_DIR/project.json" ] || printf '{"path": "%s", "name": "%s"}\n' "$_root" "${_name:-project}" > "$PRP_DIR/project.json"
mkdir -p "$PRP_DIR/research"If --follow-up: Append to existing research file instead of creating new one.
If new research:
Path: $PRP_DIR/research/{YYYY-MM-DD}-{kebab-case-topic}.md
Examples:
2025-01-08-authentication-flow.md2025-01-15-database-migration-patterns.md---
date: {ISO timestamp with timezone}
git_commit: {short hash}
branch: {branch name}
repository: {repo name}
topic: "{User's Question/Topic}"
tags: [research, codebase, {relevant-component-names}]
status: complete
last_updated: {YYYY-MM-DD}
---
# Research: {User's Question/Topic}
**Date**: {ISO timestamp}
**Git Commit**: {short hash}
**Branch**: {branch name}
**Repository**: {repo name}
## Research Question
{Original user query}
## Summary
{High-level documentation of what was found, answering the question by describing what exists}
## Detailed Findings
### {Component/Area 1}
- Description of what exists (`file.ts:123`)
- How it connects to other components
- Current implementation details
### {Component/Area 2}
...
## Code References
| File | Lines | Description |
|------|-------|-------------|
| `path/to/file.ts` | 123-145 | {What's there} |
| `another/file.ts` | 45-67 | {What's there} |
## Architecture Documentation
{Current patterns, conventions, and design implementations found}
## Open Questions
- {Areas that need further investigation}# Check if on main or pushed
git branch --show-current
gh repo view --json owner,name -q '"\(.owner.login)/\(.name)"'If on main/pushed, replace local file references with:
https://github.com/{owner}/{repo}/blob/{commit}/{file}#L{line}
If --follow-up flag and existing research file:
last_updated and add last_updated_note## Follow-up Research {timestamp}PHASE_5_CHECKPOINT:
## Research Complete
**Question**: {original question}
**Document**: `{expanded absolute path to $PRP_DIR/research/{filename}.md}`
### Summary
{2-3 sentence answer to the question}
### Key Findings
- **{Finding 1}**: {brief} (`file.ts:123`)
- **{Finding 2}**: {brief} (`file.ts:456`)
- **{Finding 3}**: {brief} (`file.ts:789`)
### Architecture
{1-2 sentence description of relevant architecture}
### Open Questions
- {Any unanswered aspects}
### Follow-up
To dig deeper: `$prp-codebase-question --follow-up {topic}`
To include external docs: `$prp-codebase-question --web {topic}`# Basic codebase question
$prp-codebase-question how does authentication work
# Include external documentation
$prp-codebase-question --web how does the PRP runner execute commands
# Follow up on previous research
$prp-codebase-question --follow-up what error handling patterns exist in the runner
# Locate and document a specific area
$prp-codebase-question where are all the command templates and how are they structuredDocument, don't evaluate. Describe what IS, never what SHOULD BE.
Evidence required. Every claim needs a file:line reference.
Agents are parallel. Launch multiple agents simultaneously when researching different areas.
Wait for completion. Never synthesize until ALL agents have returned.
Read first. If the user mentions files, read them fully before spawning agents.
No placeholders. Every field in the research document must have real values.
Codebase is truth. Live code always overrides documentation or assumptions.
file:line references{expanded absolute path to $PRP_DIR/research/}© Wirasm, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Just SKILL.md in .agents/skills/prp-codebase-question of Wirasm/prp.
Open the folder on GitHubat commit 4352925
Codebase Research Questions next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Codebase Research Questions this skillWirasm/prp | 2.3k | — | ~2.8k | Automated safety check: Pass | MIT | |
| How Does This Work Explainercursor/plugins | 10k | 6 repos | ~771 | Automated safety check: Pass | None | |
| Codebase Exploreryologdev/yoyo-evolve | 1.9k | — | ~2.8k | Automated safety check: Pass | MIT | |
| Caveman Repository ExplorerJuliusBrussee/caveman | 110k | 1 repos | ~492 | Automated safety check: Pass | Apache-2.0 | |
| Init Deep AGENTS.md Generatorcode-yeongyu/oh-my-openagent | 70k | — | ~3.5k | Automated safety check: Pass | Custom licence | |
| Hk Follow Breadcrumbdeepklarity/harness-kit | 100 | — | ~1.4k | Automated safety check: Notes | MIT |
cursor/plugins
Answers how-does-this-work and where-should-this-live questions by exploring the codebase with read-only subagents and writing an onboarding-depth explanation.
yologdev/yoyo-evolve
Builds a structural map of a large or unfamiliar codebase by dispatching sub-agents to summarize regions, keeping the main context small.
JuliusBrussee/caveman
A read-only explorer for cold-start orientation or failed searches that replies with nothing but file path and line range citations, keeping its reads out of main context.
code-yeongyu/oh-my-openagent
Generates a tree of AGENTS.md files for a repository, one at the root and more in complex subdirectories, so agents learn its structure and conventions.
deepklarity/harness-kit
Consults existing breadcrumb analysis docs before exploring the codebase.
spencerpauly/awesome-cursor-skills
Launch multiple explore subagents in parallel to investigate architecture, data models, auth, APIs, and deployment.
Wirasm/prp
Runs the plan, implement and review pipeline detached in fresh headless sessions, looping review and fix until the pull request is clean.
Wirasm/prp
Runs a detached, resumable loop that plans, implements, opens a PR, reviews and fixes a feature across headless CLI sessions until the review is clean.
Wirasm/prp
Coordinates several PRP workstreams in isolated Git worktrees from one session, verifying proof, holding merge gates and sequencing the merges.
Wirasm/prp
Turns a PRD, issue or description into an implementation-ready plan grounded in codebase evidence, adding root-cause analysis for bugs and publishing issue plans back to the issue.
Wirasm/prp
Writes an implementation-ready plan for a feature, bug fix, refactor or chore from a PRD, issue or description, grounded in codebase evidence, and can post it back to the source issue.
Wirasm/prp
Settles a feasibility question with the smallest throwaway build that could disprove it, in an isolated worktree, ending in a verdict backed by evidence instead of a PR.
Categories
Answers where and how questions about a codebase with parallel research agents and a write-up where every claim cites a file and line, describing only what exists. The agent plays technical cartographer. It reads any files you mention in full, classifies the question as where, how, what, pattern or external, and splits it into two to five research areas.
Codebase Research Questions fits situations like: asking how a part of an unfamiliar codebase works; locating where a feature, route or setting lives; finding the conventions used for something such as error handling; documenting current behavior before planning a change.
Run `npx skills add Wirasm/prp --skill prp-codebase-question -a claude-code`. Or copy the skill folder (.agents/skills/prp-codebase-question in Wirasm/prp) into .claude/skills/prp-codebase-question in your project. Claude Code loads it when a task matches its description.
Run `npx skills add Wirasm/prp --skill prp-codebase-question -a codex`. Or copy the skill folder (.agents/skills/prp-codebase-question in Wirasm/prp) into .agents/skills/prp-codebase-question in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Wirasm/prp --skill prp-codebase-question -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/prp-codebase-question, .gemini/skills/prp-codebase-question, .github/skills/prp-codebase-question and .opencode/skills/prp-codebase-question in your project.
Going by SKILL.md and its folder, Codebase Research Questions needs the command-line tools its instructions call (git and gh).
SKILL.md names 1 domain. In commands or code: github.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Codebase Research Questions is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Codebase Research Questions: How Does This Work Explainer (cursor/plugins, 10k stars), Codebase Explorer (yologdev/yoyo-evolve, 1.9k stars), Caveman Repository Explorer (JuliusBrussee/caveman, 110k stars) and Init Deep AGENTS.md Generator (code-yeongyu/oh-my-openagent, 70k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Wirasm (a GitHub user) maintains it in Wirasm/prp, which has 2,258 GitHub stars. The repository holds 37 skills in this directory. The repository was last updated on October 2, 2026.
Source: Wirasm/prp on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.