analyze

Analyze codebases read-only and return ranked evidence-based syntheses with file references.

Updated Jan 4, 2026
One-click install
npx skills add https://github.com/YeaChan05/Remittance --skill analyze-yeachan05
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: analyze
Source: https://github.com/YeaChan05/Remittance/tree/main/.codex/skills/analyze
Command: npx skills add https://github.com/YeaChan05/Remittance --skill analyze-yeachan05

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Read-only, deep analysis of a codebase that yields a ranked synthesis with explicit confidence, concrete file references, and clear evidence-vs-inference boundaries. This supports understanding architecture, behavior, and tradeoffs without attempting changes in the code.

Core Features & Use Cases

  • Read-only cross-file analysis that traces behavior across modules and surfaces concrete evidence.
  • Ranked explanations with confidence levels and explicit file references to support decision-making.
  • Suitable for debugging, architectural reviews, and rationale for refactors before any edits.

Quick Start

Ask a specific question about the codebase and receive a ranked, evidence-based synthesis with concrete file references.

Frequently Asked Questions about analyze

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I trace behavior across modules in a codebase for an architecture review?

Cross-file behavior tracing for architecture reviews requires a read-only deep repository analysis. This yields a ranked synthesis with explicit confidence levels and concrete file references to map dependencies without proposing code changes.

What is evidence-based codebase analysis and how does it handle inference?

Evidence-based codebase analysis enforces a strict evidence-vs-inference boundary to label certainty. It returns ranked explanations supported by explicit file references, ensuring conclusions trace back to concrete code rather than assumptions.

Can I use read-only repository analysis to get rationale before refactoring?

Read-only repository analysis provides rationale for refactors by surfacing concrete evidence and ranked explanations. It supports understanding tradeoffs and module behavior across the codebase without attempting edits or applying changes to files.

What's the best way to understand codebase architecture without modifying files?

Understanding codebase architecture without modifications requires a read-only deep analysis that returns ranked syntheses. This approach traces behavior across modules and enforces an evidence-vs-inference boundary with explicit confidence levels and file references.

Are there limitations to using ranked repository analysis for debugging?

Ranked repository analysis for debugging is limited to read-only operations and does not propose code changes. It focuses on cross-file reasoning and architecture explanations, meaning it provides synthesized rationale rather than automated fixes.