Can it include diagrams and code examples?

Yes. It supports Mermaid diagrams for architecture and flow, code examples from the codebase, and specific file:line references, as well as tables and lists for structured guidelines.

How does it handle large projects?

It supports depth levels (Quick, Standard, Deep) to control thoroughness and detail, while using Explore, Glob, and Grep to extract patterns, references, and critical insights.

codebase-documenter

npx machina-cli add skill mhattingpete/claude-skills-marketplace/codebase-documenter --openclaw

Files (1)

SKILL.md

3.7 KB

Codebase Documenter

Generates comprehensive documentation for codebases - architecture, components, data flow, development guidelines.

When to Use

"explain this codebase"
"document the architecture"
"how does this code work"
"create developer documentation"
"generate codebase overview"
"create onboarding docs"

What It Documents

1. Project Overview

Purpose & vision
Target users
Key features
Technology stack
Project status

2. Architecture

High-level structure
Design patterns
Data flow
Control flow
Diagrams (Mermaid)
Architectural decisions

3. Directory Structure

Organization purpose
Naming conventions
Entry points
Core modules
Configuration locations

4. Key Components

Major modules
Classes & functions
Responsibilities
Interactions
Extension points
Code examples

5. External Integrations

APIs consumed
Databases & schemas
Authentication
Caching
Message queues
File storage

6. Data Models

Database schema
Data structures
Validation
Migrations
Data transformations

7. Development Setup

Prerequisites
Installation steps
Configuration
Running the app
Testing
Debugging
Troubleshooting

8. Development Guidelines

Coding conventions
Testing approach
Error handling
Logging
Security practices
Performance patterns

9. Deployment

Build process
Deployment steps
Environments
Monitoring
Rollback procedures

10. Contributing

Development workflow
Code review guidelines
Testing requirements
Documentation updates

Approach

Explore using Explore agent (thorough)
Map structure with Glob
Read critical files (README, entry points, core modules)
Identify patterns with Grep (imports, exports)
Trace execution paths
Extract knowledge from docs, comments, tests
Synthesize into cohesive documentation

Output

Creates markdown documentation:

docs/
├── README.md              # Overview and quick start
├── ARCHITECTURE.md        # System architecture
├── DEVELOPMENT.md         # Development guide
├── API.md                 # API documentation
├── DEPLOYMENT.md          # Deployment guide
└── CONTRIBUTING.md        # Contribution guidelines

Or single comprehensive doc if preferred.

Depth Levels

Quick: High-level overview (15-30 min)
Standard: Comprehensive coverage (30-60 min)
Deep: Exhaustive with examples (60+ min)

Visual Elements

Mermaid diagrams (architecture, flow charts, sequence)
Code examples from codebase
Specific file:line references
Tables for structured info
Lists for guidelines

Tools Used

Task (Explore agent): Codebase exploration
Glob: Map directory structure
Grep: Find patterns, imports, exports
Read: Analyze key files
Write: Create documentation
Bash: Extract metadata (git log, versions)

Success Criteria

Complete coverage of all areas
Clear explanations with examples
Visual diagrams for complex concepts
Specific file:line references
Actionable setup/development instructions
New developer can onboard using only docs
Organized, navigable structure
Accurate and current information

Integration

code-auditor: Includes quality/security context
project-bootstrapper: Documents bootstrap decisions
visual-html-creator: Create visual diagrams

Source

git clone https://github.com/mhattingpete/claude-skills-marketplace/blob/main/productivity-skills-plugin/skills/codebase-documenter/SKILL.md

View on GitHub

Overview

Generates comprehensive documentation for a codebase—covering architecture, key components, data flow, and development guidelines. It helps users understand unfamiliar code, onboard new developers, document architecture, and explain how the system works.

How This Skill Works

The tool analyzes the codebase using an Explore agent, maps the directory structure with Glob, and reads critical files (README, entry points, core modules). It identifies patterns with Grep, traces execution paths, and extracts knowledge from docs, comments, and tests, then synthesizes it into cohesive Markdown docs with Mermaid diagrams, file:line references, and structured outputs like ARCHITECTURE.md, DEVELOPMENT.md, API.md, DEPLOYMENT.md, and CONTRIBUTING.md.

When to Use It

Explain this codebase
Document the architecture
How does this code work
Create onboarding docs
Generate codebase overview

Quick Start

Step 1: Run the Codebase Documenter on your project to perform a thorough Explore pass.
Step 2: Map the directory structure with Glob and read critical files (README, entry points, core modules).
Step 3: Generate Markdown docs in docs/ (e.g., README.md, ARCHITECTURE.md, DEVELOPMENT.md, API.md, DEPLOYMENT.md) or a single comprehensive document.

Best Practices

Start with key entry points (README, core modules) to anchor the docs.
Choose the appropriate depth level (Quick, Standard, Deep) for your audience.
Incorporate Mermaid diagrams to illustrate architecture and data flow.
Include specific file:line references and relevant code examples.
Keep the generated docs up to date with regular codebase updates.

Example Use Cases

Document a legacy codebase to reveal architecture and data flow for maintenance teams.
Onboard a new engineer to a microservices system with architecture and deployment docs.
Document API surfaces and data models for internal developers and QA.
Create a development guide and contribution workflow for a new project.
Generate a comprehensive project overview for stakeholders and external auditors.

Frequently Asked Questions

Add this skill to your agents