codebase-recon

Map codebase structure and entry points with targeted scripts.

Updated Jan 5, 2026
One-click install
npx skills add https://github.com/Maxcogar/agent-armory --skill codebase-recon
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: codebase-recon
Source: https://github.com/Maxcogar/agent-armory/tree/main/skills/codebase-recon/files
Command: npx skills add https://github.com/Maxcogar/agent-armory --skill codebase-recon

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Efficient codebase understanding using targeted scripts instead of brute-force file reading. Use when exploring unfamiliar code, planning features, debugging, or needing to understand how components connect. Triggers on "understand this codebase", "how does X work", "where is Y used", "what calls Z", or any task requiring codebase context.

Core Features & Use Cases

  • Script-driven discovery: detect project type, map the skeleton, identify entry points, and surface core abstractions.
  • Targeted deep-dives: locate definitions and usages, trace data flow, and scope changes with minimal file reads.
  • Use Case: When joining a new codebase, run recon to quickly determine entry points, major modules, and dependencies before reading code.

Quick Start

Invoke the Recon workflow to discover the project, map its skeleton, and perform targeted deep-dives as needed.

Frequently Asked Questions about codebase-recon

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

FAQPage Schema
How do I understand an unfamiliar codebase without reading every file?

To understand an unfamiliar codebase, use script-driven discovery to detect project type, map the skeleton, and identify entry points. This minimizes file reads by surfacing core abstractions and providing a context map for targeted exploration.

What is the best way to find entry points and major modules in a new codebase?

The best way to find entry points and major modules is running a recon workflow. It detects the project type, maps the structural skeleton, and surfaces core abstractions to guide your exploration with minimal file reads.

How do I locate where a specific function is defined and used across a project?

To locate definitions and usages across a project, use targeted deep-dives. This technique traces data flow and scopes changes by identifying exactly where specific functions or components are called without reading entire files.

Can I trace data flow and dependencies using codebase analysis scripts?

Yes, you can trace data flow and dependencies using codebase analysis scripts. The recon workflow maps the skeleton, identifies core abstractions, and performs targeted deep-dives to locate definitions, usages, and connections between components.

Does this codebase analysis approach work for large projects with many dependencies?

Yes, this codebase analysis approach works for large projects by using script-driven discovery to map dependencies and identify hot files. It scopes changes and guides targeted exploration, making it efficient for complex projects with many interconnected modules.

When should I use targeted scripts instead of brute-force file reading for code exploration?

You should use targeted scripts instead of brute-force file reading when exploring unfamiliar code, planning features, or debugging. This approach provides a concise context map and identifies hot files, preventing unnecessary reads and accelerating understanding.