Agent skill

Codebase Question Research

by Wirasm in Wirasm/prp

Answers how-and-where questions about a codebase by running parallel explorer agents and writing a research document where every claim cites file and line.

MITAuto-check passedAgent Workflows

Install Codebase Question Research

skills CLI
$ npx skills add Wirasm/prp --skill prp-codebase-question -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Wirasm/prp prp-codebase-question --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Wirasm/prp.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/prp-codebase-question .claude/skills/prp-codebase-question && rm -rf skills-src

Use ~/.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/

Facts

Skill name
prp-codebase-question
GitHub stars
2.3k
Token cost
~2.8k tokens
SKILL.md length
761 words
Files
1
Skills in repo
37
Repo updated
First seen
Licence
MIT

At a glance

Answers how-and-where questions about a codebase by running parallel explorer agents and writing a research document where every claim cites file and line.

  • Works in 6 steps: PARSE - Understand the Query → DECOMPOSE - Break into Research Areas → EXPLORE - Spawn Parallel Agents → …
  • Learning how a feature works across several modules
  • SKILL.md covers Your Mission, CRITICAL: Documentarian Only, Phase 1: PARSE - Understand… and Phase 2: DECOMPOSE - Break…, plus 7 more sections
  • Calls git and gh; reaches github.com

What it does

The agent acts as a documentarian: it describes what exists, where it lives and how components interact, with no suggestions, critique, refactoring advice or root cause analysis unless asked. Every claim needs a file and line reference. It starts by reading any files you mention in full, then classifies the question as where, how, what, pattern or external, and notes the web and follow-up flags.

The query is split into two to five research areas and sent to specialized agents: an explorer for locating code and patterns, an analyst for tracing flow and integration points, and a web researcher used only with the web flag or an explicit request for outside documentation. The findings are combined into one research document, and the follow-up flag appends to an existing one.

When your agent uses it

  • Learning how a feature works across several modules
  • Locating where a piece of behavior is implemented
  • Writing up a neutral map of existing code before planning changes

Example prompts

  • “How does authentication flow from the login handler to the session store? Cite file and line.”
  • “Where do we define retry behavior, and what conventions do those files follow?”

Requirements

  • The prp-core agents for exploring and analyzing the codebase

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. PARSE - Understand the Query
  2. DECOMPOSE - Break into Research Areas
  3. EXPLORE - Spawn Parallel Agents
  4. SYNTHESIZE - Merge Findings
  5. DOCUMENT - Generate Research File
  6. OUTPUT - Present to User

What it can do on your machine

Read from SKILL.md and the folder at commit 4352925. It shows what the files ask for, not the result of running them.

  • Tool permissions

    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.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Codebase Question Research loads about 2.8k tokens when it runs. Until then it costs about 56 tokens; SKILL.md has 761 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~56
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k

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.

Safety

Auto-check passed

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.

SKILL.md

The full file from Wirasm/prp at commit 4352925, republished under its MIT licence (© Wirasm). 761 words, ~2,789 tokens.

Download SKILL.mdSave it as .claude/skills/prp-codebase-question/SKILL.md (or your agent's skills folder).
name
prp-codebase-question
description
Research codebase questions using parallel agents - documents what exists, not what should change. Use when the user asks how the codebase works, where something lives, or invokes /prp-codebase-question.
argument-hint
<question or topic> [--web] [--follow-up]

Codebase Research

Input: $ARGUMENTS


Your Mission

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.


CRITICAL: Documentarian Only

  • DO NOT suggest improvements or changes
  • DO NOT perform root cause analysis unless explicitly asked
  • DO NOT propose future enhancements
  • DO NOT critique implementations or identify problems
  • DO NOT recommend refactoring or optimization
  • ONLY describe what exists, where it exists, how it works, and how components interact

Phase 1: PARSE - Understand the Query

1.1 Read Mentioned Files

If the user mentions specific files, read them FULLY first (no limit/offset) before any decomposition.

1.2 Classify the Query
TypeIndicatorsAgent Focus
Where"where is", "find", "locate"prp-core:codebase-explorer primary
How"how does", "trace", "flow"prp-core:codebase-analyst primary
What"what is", "explain", "describe"Both agents in parallel
Pattern"how do we", "convention", "examples"prp-core:codebase-explorer primary
External"docs", "best practice", "API"Add prp-core:web-researcher
1.3 Determine Scope
  • Identify specific components, patterns, or concepts to investigate
  • Note any --web flag for external research
  • Note any --follow-up flag for appending to existing research

PHASE_1_CHECKPOINT:

  • Mentioned files read in full
  • Query type classified
  • Research scope identified
  • Flags parsed (--web, --follow-up)

Phase 2: DECOMPOSE - Break into Research Areas

2.1 Create Research Plan

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}
2.2 Agent Selection
AgentUse When
prp-core:codebase-explorerFinding WHERE code lives, locating files, extracting patterns, discovering conventions
prp-core:codebase-analystUnderstanding HOW code works, tracing data flow, mapping integration points
prp-core:web-researcherOnly when --web flag is set or user explicitly asks for external docs

Strategy:

  1. Start with prp-core:codebase-explorer to find what exists
  2. Then use prp-core:codebase-analyst on the most relevant findings to trace how they work
  3. Run agents in parallel when they're searching for different areas

PHASE_2_CHECKPOINT:

  • Query decomposed into 2-5 research areas
  • Agent assigned to each area
  • Parallel vs sequential execution planned

Phase 3: EXPLORE - Spawn Parallel Agents

3.1 Launch Codebase Agents

Launch agents in parallel using multiple Task tool calls in a single message.

For each research area, use the appropriate agent:

prp-core: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.

prp-core: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.
3.2 Launch Web Research (if --web or explicitly requested)

prp-core:web-researcher:

Research external documentation for: {topic}

FIND:
1. {Specific documentation needed}
2. {API references or patterns}

Return findings with direct links and citations.
3.3 Wait for All Agents

IMPORTANT: Wait for ALL agents to complete before proceeding.

PHASE_3_CHECKPOINT:

  • All agents launched (parallel where possible)
  • All agents completed
  • Results collected from each agent

Phase 4: SYNTHESIZE - Merge Findings

4.1 Compile Results
  • Prioritize live codebase findings as primary source of truth
  • Connect findings across different components
  • Include specific file:line references throughout
  • Document patterns, connections, and architectural decisions as they exist
4.2 Answer the Question

Map findings back to the user's original question:

Question AspectFindingEvidence
{aspect 1}{what was found}file.ts:123
{aspect 2}{what was found}file.ts:456
Show full SKILL.md (297 more words)Show less
4.3 Identify Gaps

Note any areas that couldn't be fully documented:

  • {Area that needs further investigation}
  • {Question that remains open}

PHASE_4_CHECKPOINT:

  • All agent results synthesized
  • Findings connected across components
  • Original question answered with evidence
  • Gaps identified

Phase 5: DOCUMENT - Generate Research File

5.1 Gather Metadata
bash
date -u +"%Y-%m-%dT%H:%M:%SZ"
git rev-parse --short HEAD
git branch --show-current
basename $(git rev-parse --show-toplevel)
5.2 Create Research Directory
bash
# --- 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"
5.3 Determine Filename

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.md
  • 2025-01-15-database-migration-patterns.md
5.4 Write Research Document
markdown
---
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}
bash
# 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}

5.6 Handle Follow-ups

If --follow-up flag and existing research file:

  1. Read the existing research file
  2. Update frontmatter: last_updated and add last_updated_note
  3. Append new section: ## Follow-up Research {timestamp}
  4. Spawn new agents as needed
  5. Save updated document

PHASE_5_CHECKPOINT:

  • Metadata gathered
  • Research file created (or existing file updated for follow-up)
  • All sections filled with evidence-based content
  • GitHub permalinks added (if applicable)
  • No placeholder values remain

Phase 6: OUTPUT - Present to User

markdown
## 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}`

Usage Examples

bash
# 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 structured

Critical Reminders

  1. Document, don't evaluate. Describe what IS, never what SHOULD BE.

  2. Evidence required. Every claim needs a file:line reference.

  3. Agents are parallel. Launch multiple agents simultaneously when researching different areas.

  4. Wait for completion. Never synthesize until ALL agents have returned.

  5. Read first. If the user mentions files, read them fully before spawning agents.

  6. No placeholders. Every field in the research document must have real values.

  7. Codebase is truth. Live code always overrides documentation or assumptions.


Success Criteria

  • QUESTION_ANSWERED: User's question addressed with concrete evidence
  • AGENTS_USED: Specialized agents spawned for each research area
  • EVIDENCE_COMPLETE: Every finding has file:line references
  • DOCUMENT_CREATED: Research file saved at {expanded absolute path to $PRP_DIR/research/}
  • NO_OPINIONS: Document describes what exists, not what should change
  • PERMALINKS_ADDED: GitHub links included when possible

© Wirasm, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/prp-codebase-question of Wirasm/prp.

Open the folder on GitHubat commit 4352925

Compare with similar skills

Codebase Question Research 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.

Codebase Question Research compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Codebase Question Research this skillWirasm/prp2.3k—~2.8kAutomated safety check: PassMIT
Codebase Handbook BuilderRuhan-Wang/Harness_Handbook331—~2.2kAutomated safety check: PassApache-2.0
Document Featureiopsystems/rezolus275—~2.2kAutomated safety check: PassCustom licence
Codebase Exploreryologdev/yoyo-evolve1.9k—~2.8kAutomated safety check: PassMIT
Docs Syncncatbot/NcatBot115—~1.3kAutomated safety check: PassCustom licence
Caveman Repository ExplorerJuliusBrussee/caveman110k1 repos~492Automated safety check: PassApache-2.0

Similar skills

  • Codebase Handbook Builder

    Ruhan-Wang/Harness_Handbook

    Generates, refreshes, validates and uses a compact handbook that maps where a change touches in a repository, using the active Codex session and no external LLM API.

    331 GitHub stars~2.2k tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed
  • Document Feature

    iopsystems/rezolus

    Write or update the CLI --help text and README section for a new or changed rezolus feature (a subcommand, flag, mode, or behavior change), then prove the help is usable by dispatching a fresh…

    275 GitHub stars~2.2k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Codebase Explorer

    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.

    1.9k GitHub stars~2.8k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Docs Sync

    ncatbot/NcatBot

    整体/局部防腐检查:Docs 内部链接断裂、README 索引不同步、guide↔reference 内容不一致、examples 导入过时、Code↔Docs API 对齐。逐文件检查,最大化并发 subagent。Use when: docs 防腐、docs 链接、docs 断链、断链检查、docs 审计、docs audit、code docs 对齐、reference 过时、guide…

    115 GitHub stars~1.3k tokensUpdated 3 days ago
    Agent WorkflowsAuto-check passed
  • Caveman Repository Explorer

    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.

    110k GitHub starsUsed in 1 repo~492 tokens
    Agent WorkflowsAuto-check passed
  • Init Deep AGENTS.md Generator

    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.

    70k GitHub stars~3.5k tokensUpdated today
    Agent WorkflowsAuto-check passed

More from Wirasm/prp

All 37 skills in this repo
  • PRP Loop

    Wirasm/prp

    Runs the plan, implement and review pipeline detached in fresh headless sessions, looping review and fix until the pull request is clean.

    2.3k GitHub stars~894 tokensUpdated 5 days ago
    Auto-check passed
  • 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.

    2.3k GitHub stars~863 tokensUpdated 5 days ago
    Auto-check passed
  • Coordinates several PRP workstreams in isolated Git worktrees from one session, verifying proof, holding merge gates and sequencing the merges.

    2.3k GitHub stars~3.5k tokensUpdated 5 days ago
    Auto-check passed
  • 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.

    2.3k GitHub stars~4.1k tokensUpdated 5 days ago
    Auto-check passed
  • PRP Plan

    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.

    2.3k GitHub stars~4k tokensUpdated 5 days ago
    Auto-check passed
  • PRP Spike

    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.

    2.3k GitHub stars~3.8k tokensUpdated 5 days ago
    Auto-check passed

Questions about Codebase Question Research

What does Codebase Question Research do?

Answers how-and-where questions about a codebase by running parallel explorer agents and writing a research document where every claim cites file and line. The agent acts as a documentarian: it describes what exists, where it lives and how components interact, with no suggestions, critique, refactoring advice or root cause analysis unless asked. Every claim needs a file and line reference.

When should I use Codebase Question Research?

Codebase Question Research fits situations like: learning how a feature works across several modules; locating where a piece of behavior is implemented; writing up a neutral map of existing code before planning changes.

How do I install Codebase Question Research in Claude Code?

Run `npx skills add Wirasm/prp --skill prp-codebase-question -a claude-code`. Or copy the skill folder (.claude/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.

How do I install Codebase Question Research in Codex?

Run `npx skills add Wirasm/prp --skill prp-codebase-question -a codex`. Or copy the skill folder (.claude/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.

Can I use Codebase Question Research in Cursor, Gemini CLI or GitHub Copilot?

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.

What does Codebase Question Research need to run?

Going by SKILL.md and its folder, Codebase Question Research needs the command-line tools its instructions call (git and gh). Our summary lists: The prp-core agents for exploring and analyzing the codebase.

Does Codebase Question Research access the network?

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.

Is Codebase Question Research safe to install?

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.

What licence does Codebase Question Research use?

Codebase Question Research is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Codebase Question Research use?

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.

What are the alternatives to Codebase Question Research?

Skills that share tags, products or a category with Codebase Question Research: Codebase Handbook Builder (Ruhan-Wang/Harness_Handbook, 331 stars), Document Feature (iopsystems/rezolus, 275 stars), Codebase Explorer (yologdev/yoyo-evolve, 1.9k stars) and Docs Sync (ncatbot/NcatBot, 115 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Codebase Question Research?

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.