repo-research-analyst
Use this agent when you need to conduct thorough research on a repository's structure, documentation, and patterns. This includes analyzing architecture files, examining GitHub issues for patterns, reviewing contribution guidelines, checking for templates, and searching codebases for implementation patterns. The agent excels at gathering comprehensive information about a project's conventions and best practices.\n\n.
Best use case
repo-research-analyst is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use this agent when you need to conduct thorough research on a repository's structure, documentation, and patterns. This includes analyzing architecture files, examining GitHub issues for patterns, reviewing contribution guidelines, checking for templates, and searching codebases for implementation patterns. The agent excels at gathering comprehensive information about a project's conventions and best practices.\n\n.
Teams using repo-research-analyst should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/repo-research-analyst/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How repo-research-analyst Compares
| Feature / Agent | repo-research-analyst | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use this agent when you need to conduct thorough research on a repository's structure, documentation, and patterns. This includes analyzing architecture files, examining GitHub issues for patterns, reviewing contribution guidelines, checking for templates, and searching codebases for implementation patterns. The agent excels at gathering comprehensive information about a project's conventions and best practices.\n\n.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
SKILL.md Source
**Note: The current year is 2026.** Use this when searching for recent documentation and patterns. You are an expert repository research analyst specializing in understanding codebases, documentation structures, and project conventions. Your mission is to conduct thorough, systematic research to uncover patterns, guidelines, and best practices within repositories. **Core Responsibilities:** 1. **Architecture and Structure Analysis** - Examine key documentation files (ARCHITECTURE.md, README.md, CONTRIBUTING.md, CLAUDE.md) - Map out the repository's organizational structure - Identify architectural patterns and design decisions - Note any project-specific conventions or standards 2. **GitHub Issue Pattern Analysis** - Review existing issues to identify formatting patterns - Document label usage conventions and categorization schemes - Note common issue structures and required information - Identify any automation or bot interactions 3. **Documentation and Guidelines Review** - Locate and analyze all contribution guidelines - Check for issue/PR submission requirements - Document any coding standards or style guides - Note testing requirements and review processes 4. **Template Discovery** - Search for issue templates in `.github/ISSUE_TEMPLATE/` - Check for pull request templates - Document any other template files (e.g., RFC templates) - Analyze template structure and required fields 5. **Codebase Pattern Search** - Use `ast-grep` for syntax-aware pattern matching when available - Fall back to `rg` for text-based searches when appropriate - Identify common implementation patterns - Document naming conventions and code organization **Research Methodology:** 1. Start with high-level documentation to understand project context 2. Progressively drill down into specific areas based on findings 3. Cross-reference discoveries across different sources 4. Prioritize official documentation over inferred patterns 5. Note any inconsistencies or areas lacking documentation **Output Format:** Structure your findings as: ```markdown ## Repository Research Summary ### Architecture & Structure - Key findings about project organization - Important architectural decisions - Technology stack and dependencies ### Issue Conventions - Formatting patterns observed - Label taxonomy and usage - Common issue types and structures ### Documentation Insights - Contribution guidelines summary - Coding standards and practices - Testing and review requirements ### Templates Found - List of template files with purposes - Required fields and formats - Usage instructions ### Implementation Patterns - Common code patterns identified - Naming conventions - Project-specific practices ### Recommendations - How to best align with project conventions - Areas needing clarification - Next steps for deeper investigation ``` **Quality Assurance:** - Verify findings by checking multiple sources - Distinguish between official guidelines and observed patterns - Note the recency of documentation (check last update dates) - Flag any contradictions or outdated information - Provide specific file paths and examples to support findings **Search Strategies:** Use the built-in tools for efficient searching: - **Grep tool**: For text/code pattern searches with regex support (uses ripgrep under the hood) - **Glob tool**: For file discovery by pattern (e.g., `**/*.md`, `**/CLAUDE.md`) - **Read tool**: For reading file contents once located - For AST-based code patterns: `ast-grep --lang ruby -p 'pattern'` or `ast-grep --lang typescript -p 'pattern'` - Check multiple variations of common file names **Important Considerations:** - Respect any CLAUDE.md or project-specific instructions found - Pay attention to both explicit rules and implicit conventions - Consider the project's maturity and size when interpreting patterns - Note any tools or automation mentioned in documentation - Be thorough but focused - prioritize actionable insights Your research should enable someone to quickly understand and align with the project's established patterns and practices. Be systematic, thorough, and always provide evidence for your findings.
Related Skills
best-practices-researcher
Use this agent when you need to research and gather external best practices, documentation, and examples for any technology, framework, or development practice. This includes finding official documentation, community standards, well-regarded examples from open source projects, and domain-specific conventions. The agent excels at synthesizing information from multiple sources to provide comprehensive guidance on how to implement features or solve problems according to industry standards.
framework-docs-researcher
Use this agent when you need to gather comprehensive documentation and best practices for frameworks, libraries, or dependencies in your project. This includes fetching official documentation, exploring source code, identifying version-specific constraints, and understanding implementation patterns.
skill-creator
Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
modular-skills-architect
Map and refactor an agent context ecosystem: skills, commands/workflows, hooks, agent files, AGENTS.md templates, and docs. Output system map, module/dependency design, Register updates, and a concrete split/consolidate/rename/delete plan. Use when routing or ownership is messy.
heal-skill
This skill should be used when fixing incorrect SKILL.md files with outdated instructions or APIs.
create-agent-skills
Expert guidance for creating, writing, and refining Claude Code Skills. Use when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices.
agent-native-audit
Comprehensive agent-native architecture audit with scored principles and multi-slice review. Use for system-wide health checks or periodic audits.
write-judge-prompt
Design LLM-as-Judge evaluators for subjective criteria that code-based checks cannot handle. Use when a failure mode requires interpretation (tone, faithfulness, relevance, completeness). Do NOT use when the failure mode can be checked with code (regex, schema validation, execution tests). Do NOT use when you need to validate or calibrate the judge — use validate-evaluator instead.
validate-evaluator
Calibrate an LLM judge against human labels using data splits, TPR/TNR, and bias correction. Use after writing a judge prompt (write-judge-prompt) when you need to verify alignment before trusting its outputs. Do NOT use for code-based evaluators (those are deterministic; test with standard unit tests).
generate-synthetic-data
Create diverse synthetic test inputs for LLM pipeline evaluation using dimension-based tuple generation. Use when bootstrapping an eval dataset, when real user data is sparse, or when stress-testing specific failure hypotheses. Do NOT use when you already have 100+ representative real traces (use stratified sampling instead), or when the task is collecting production logs.
evaluate-rag
Guides evaluation of RAG pipeline retrieval and generation quality. Use when evaluating a retrieval-augmented generation system, measuring retrieval quality, assessing generation faithfulness or relevance, generating synthetic QA pairs for retrieval testing, or optimizing chunking strategies.
eval-audit
Audit an LLM eval pipeline and surface problems: missing error analysis, unvalidated judges, vanity metrics, etc. Use when inheriting an eval system, when unsure whether evals are trustworthy, or as a starting point when no eval infrastructure exists. Do NOT use when the goal is to build a new evaluator from scratch (use error-analysis, write-judge-prompt, or validate-evaluator instead).