exploration

Analyzes unfamiliar codebases through a 5-phase reconnaissance protocol detecting architecture patterns and dependencies.

1|Updated Jul 29, 2026
One-click install
npx skills add https://github.com/fusengine/kimi-code --skill exploration-fusengine
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: exploration
Source: https://github.com/fusengine/kimi-code/tree/main/plugins/ai-pilot/skills/exploration
Command: npx skills add https://github.com/fusengine/kimi-code --skill exploration-fusengine

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? When you land in an unfamiliar codebase, you waste time manually hunting for entry points, config files, and architectural conventions. This Skill runs a systematic 5-phase reconnaissance protocol that maps structure, detects entry points, analyzes dependencies, and identifies architecture patterns with evidence-based findings only. ## Core Features & Use Cases - 5-Phase Exploration Protocol: Initial reconnaissance, structure mapping, entry-point detection, dependency analysis, and architecture-pattern detection with exact shell commands per phase. - Multi-Language Tech Stack Detection: Identifies frameworks, ORMs, and tooling across JavaScript/TypeScript, Python, Go, PHP, and Rust from manifest files like package.json, pyproject.toml, go.mod, Cargo.toml, and composer.json. - Architecture Pattern Recognition: Detects MVC, Clean Architecture, Hexagonal, feature-based, layered, microservices, modular monolith, and Next.js App Router layouts from directory indicators. - Use Case: Before starting a feature in a repo you have never seen, run the exploration to get a structured report of the tech stack, entry points, detected architecture, and potential code-organization issues to feed into planning. ## Quick Start Explore this repository and produce a structured report of its tech stack, entry points, and architecture pattern.

Frequently Asked Questions about exploration

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

FAQPage Schema
How do I explore an unfamiliar codebase quickly?▼

Run a 5-phase protocol: list root and config files, map the directory tree excluding noise folders, grep for entry points per language, read dependency manifests like package.json or go.mod, then detect architecture patterns from directory names.

How to detect the architecture pattern of a repository?▼

Check for indicator directories: controllers/models/views signal MVC, domain/application/infrastructure signal Clean Architecture, adapters/ports signal Hexagonal, and app/components/lib signal Next.js App Router. Always confirm with code evidence rather than assumptions.

What files reveal a project's tech stack?▼

Manifest files reveal the stack: package.json and tsconfig.json for JavaScript/TypeScript, pyproject.toml and requirements.txt for Python, go.mod for Go, composer.json for PHP, and Cargo.toml for Rust. Framework-specific configs like next.config or vite.config add detail.

Does codebase exploration work for Go and Rust projects?▼

Yes, the protocol includes Go and Rust detection. For Go it greps for func main and reads go.mod for frameworks like gin or echo; for Rust it checks Cargo.toml and distinguishes library crates (src/lib.rs) from binary crates (src/main.rs).

Why should codebase analysis avoid assumptions?▼

Assumptions without code evidence produce wrong architecture conclusions that mislead downstream planning. The protocol forbids skipping dependency analysis, ignoring config files, or declaring a pattern without verifying its indicator directories exist.