analyze-architecture
Comprehensive brownfield architecture analysis for existing codebases. Discovers structure, identifies patterns, assesses quality, calculates production readiness, and provides actionable recommendations. Use when analyzing existing codebases to understand architecture, assess quality, or prepare for modernization.
npx skills add majiayu000/claude-skill-registry --skill analyze-architecture-adolfoaranaes12-bmad-enhanced --agent claude-code
Same command for any agent — swap --agent for codex, cursor, copilot.
Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.
What it does
Compels an AI agent to perform a comprehensive, production-ready architecture analysis of an existing codebase, including discovering structure, detecting project type, analyzing tech stack, identifying architectural patterns, evaluating quality, scoring production readiness, generating recommendations, and producing a full report. The analysis is tailored for brownfield projects without existing documentation and emphasizes actionable insights and a structured output.
How it works
- Discovers the codebase structure and candidate components, with an option to skip if recent architecture docs exist or if package.json files are parsed.
- Detects project type (frontend, backend, fullstack, or monorepo) using indicators such as dependencies, directories, and tooling.
- Analyzes the technology stack by aggregating runtime, frameworks, ORM/DB, caching, queues, auth, validation, testing, and dev tools, alongside frontend and infrastructure details.
- Identifies architectural patterns by scanning for signals of DDD, CQRS, layered architecture, microservices, event-driven design, hexagonal patterns, and repository usage, returning evidence for each pattern.
- Evaluates domain model if applicable (entities, value objects, aggregates, domain events, services, and CQRS handlers).
- Assesses API architecture by locating endpoints, middleware, versioning, and authentication/authorization approaches, and classifies API style (REST, GraphQL, tRPC, gRPC).
- Reviews data architecture including database schema, migrations, and related infrastructure.
- Produces outputs including a report, detected project type, patterns, production readiness score, quality scores, technical debt items, and prioritized recommendations, with telemetry hooks for completion and key metrics.
When to use it
- Use when analyzing an existing codebase to understand architecture, assess quality, or prepare for modernization. Triggered by situations requiring a production-focused, comprehensive architecture evaluation for brownfield projects.
What it can touch
- Codebase files and structure on the filesystem
- package.json files and other config files
- Prisma schema and migrations (schema.prisma)
- Source code under src or similar paths where patterns and API definitions live
- Documentation files like docs/architecture.md if present
- Telemetry endpoints for reporting completion and metrics
Caveats
- Requires filesystem access to the codebase and read access to source files
- Behavior may adapt to token budget constraints and may exit early if documentation exists or budgets are exceeded
- Outputs depend on the presence of conventional project structures and detectable patterns; sparse or non-standard codebases may yield limited pattern signals
# Analyze Architecture (Brownfield) ## Purpose Perform comprehensive, production-ready architecture analysis of existing codebases. Designed for brownfield projects where formal architecture documentation may not exist. Discovers structure, identifies patterns, assesses quality across 8 dimensions, and provides actionable recommendations. **Core Principles:** - **Discovery-first:** Understand what exists before judging - **Pattern recognition:** Identify architectural patterns in use - **Multi-dimensional:** Quality assessment across 8 key areas - **Actionable insights:** Prioritized recommendations with effort estimates - **Production focus:** Calculate readiness for production deployment - **Brownfield-optimized:** Works without existing documentation --- ## Prerequisites - Codebase accessible on filesystem - Read access to all source files - Build configuration files present (package.json, etc.) - Database schema files accessible (if applicable) --- ## Workflow Modes Choose the analysis depth based on time constraints and requirements: ### Quick Mode (`--depth quick`) **Duration:** 5-7 minutes **Token Usage:** ~50,000 tokens **Steps:** 1-8 only **Output:** Executive summary + ke
- Purpose
- Prerequisites
- Workflow Modes
- Quick Mode (--depth quick)
- Standard Mode (--depth standard) [DEFAULT]
- Comprehensive Mode (--depth comprehensive)
- Adaptive Workflow
- Workflow
- 1. Discover Codebase Structure
- 2. Detect Project Type
- 3. Analyze Technology Stack
- 4. Identify Architectural Patterns
- 5. Evaluate Domain Model (if DDD/CQRS)
- 6. Assess API Architecture
Check for existing architecture docs
find {codebase_path}/docs -name "*architecture*.md" -mtime -30 2>/dev/null
If no recent docs, discover structure
Find all major directories and files
find {codebase_path} -maxdepth 3 -type d | head -50
find {codebase_path} -name "package.json" -o -name "*.config.*" -o -name "tsconfig.json"
Read all package.json files
find {codebase_path} -name "package.json" -not -path "*/node_modules/*" -exec cat {} \;
Extract tech stack using primitive (preferred)
python .claude/skills/bmad-commands/scripts/extract_tech_stack.py \What does the analyze-architecture skill do?
Comprehensive brownfield architecture analysis for existing codebases. Discovers structure, identifies patterns, assesses quality, calculates production readiness, and provides actionable recommendations. Use when analyzing existing codebases to understand architecture, assess quality, or prepare for modernization.
How do I install it?
Run `npx skills add majiayu000/claude-skill-registry --skill analyze-architecture-adolfoaranaes12-bmad-enhanced --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.
Where does this skill come from?
From majiayu000/claude-skill-registry, a repository with 534 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.
Is a popular skill a good skill?
Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.