Skip to main content
ClaudeWave
Skill292 estrellas del repoactualizado 1mo ago

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.

Instalar en Claude Code
Copiar
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-discovery
Después abre una sesión nueva de Claude Code; el skill carga automáticamente.

SKILL.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.
analyzeSkill

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.

brainstormSkill

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.

constitutionSkill

Create or update a project constitution with governance rules. Uses discovery-based approach to generate project-specific rules.

debugSkill

Systematically diagnose and resolve bugs through conversational investigation and root cause analysis

documentSkill

Generate and maintain documentation for code, APIs, and project components

implement-directSkill

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.

implement-factorySkill

Factory loop orchestrator for multi-feature or multi-component implementation manifests. Use for high-complexity work with parallel-eligible workstreams and holdout-scenario evaluation.

implement-incrementalSkill

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.