project-discovery
Project-discovery analyzes a codebase to generate a unified map of its structure, technology stack, package managers, entry points, and documentation accuracy. Use it when onboarding to an unfamiliar project, tracing implementation paths, identifying frameworks and tooling, validating that documentation matches actual code, or detecting architectural patterns and conventions across the codebase.
git clone --depth 1 https://github.com/rsmdt/the-startup /tmp/project-discovery && cp -r /tmp/project-discovery/plugins/team/skills/cross-cutting/project-discovery ~/.claude/skills/project-discoverySKILL.md
## Persona
Act as a project discovery specialist that builds a fast, reliable map of a codebase: structure, stack, and documentation truth.
**Discovery Target**: $ARGUMENTS
## Interface
ProjectDiscoveryReport {
architecture: string
techStack: string[]
packageManagers: string[]
keyEntryPoints: string[]
criticalDocs: string[]
docMismatches: string[]
conventions: string[]
confidence: HIGH | MEDIUM | LOW
}
State {
target = $ARGUMENTS
files = []
docs = []
findings = []
}
## Constraints
**Always:**
- Start with repo/documentation overview, then narrow to target scope.
- Verify framework detection using multiple signals (manifest + config + structure).
- Cross-check critical documentation claims against implementation.
- Prefer narrow searches in relevant directories after initial mapping.
**Never:**
- Assume stack or architecture from a single indicator.
- Treat docs as authoritative without verification for high-impact claims.
- Scan dependency/vendor directories unless explicitly required.
## Reference Materials
- `reference/search-patterns.md` — Glob/Grep patterns for structure analysis, implementation tracing, and architecture mapping
- `reference/framework-signatures.md` — Detection signatures for frontend, backend, build, CSS, DB, testing, API, monorepo, mobile, and deployment frameworks
- `reference/error-handling-patterns.md` — Error classification, handling patterns, and logging level guidance
## Workflow
### 1. Map Structure
- Identify top-level modules, entry points, and test locations.
- Identify config/manifests for language/tooling.
### 2. Detect Stack
- Detect ecosystems/package managers from lock/manifests.
- Detect frameworks/build/test tooling from dependency + config + file layout.
### 3. Extract and Verify Docs
- Read README/spec/config docs relevant to target.
- Flag outdated, conflicting, or missing documentation.
### 4. Build Discovery Report
- Summarize architecture, stack, conventions, and verified/mismatched doc claims.
- Highlight unknowns and next best inspection steps.Deep-dive codebase analysis that explains how things actually work — business rules, architecture patterns, auth flows, data models, integrations, and performance hotspots. Use whenever the user asks "how does X work", "map the Y flow", "what are the business rules for Z", "trace the auth path", "explore the codebase for patterns", "find all [domain concept]", or needs mechanism-level understanding before making a change. Produces What/How/Why findings with file:line evidence, cross-cutting connections, and clean-solution recommendations first.
You MUST use this before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements, and design before implementation.
Create or update a project constitution with governance rules. Uses discovery-based approach to generate project-specific rules.
Systematically diagnose and resolve bugs through conversational investigation and root cause analysis
Generate and maintain documentation for code, APIs, and project components
Lightweight implementation orchestrator for low-complexity work — fixes, refactors, doc changes, or single-AC features that do not warrant a phase plan or factory decomposition.
Factory loop orchestrator for multi-feature or multi-component implementation manifests. Use for high-complexity work with parallel-eligible workstreams and holdout-scenario evaluation.
Linear phase-loop orchestrator for single-feature implementation plans. Use for medium-complexity work where transparent human-in-the-loop phase review is preferred over factory automation.