Documentation Bootstrapper Skill

Purpose

This skill creates initial documentation structure for projects that lack proper documentation. It detects project type and generates appropriate documentation templates, including README, architecture overview, and API documentation.

When to Activate

Use this skill when:

• Starting a new project without documentation
• Existing project lacks basic documentation structure
• docs-analyzer identifies missing documentation structure
• User explicitly requests documentation bootstrapping
• Migrating from undocumented codebase

Core Workflow

Step 1: Check Existing Documentation

Before bootstrapping, verify what documentation already exists:

Check for:

• README.md (root)
• docs/ directory
• CONTRIBUTING.md
• Architecture documentation
• API documentation

Decision:

• If comprehensive docs exist: Skip bootstrapping, report status
• If partial docs exist: Ask user if they want to supplement
• If no docs exist: Proceed with full bootstrap

Step 2: Detect Project Type

Analyze the codebase to determine project type and technology stack.

Backend Projects

Django:

• Indicators: manage.py, settings.py, requirements.txt with Django
• Framework: Django + DRF
• Components: ViewSets, Models, Serializers, Migrations

FastAPI:

• Indicators: main.py, requirements.txt with fastapi
• Framework: FastAPI + Pydantic
• Components: Route handlers, Schemas, Dependencies

Express:

• Indicators: package.json with express, app.js or server.js
• Framework: Express.js
• Components: Routes, Controllers, Middleware

NestJS:

• Indicators: nest-cli.json, package.json with @nestjs
• Framework: NestJS
• Components: Controllers, Services, Modules

Flask:

• Indicators: app.py, requirements.txt with flask
• Framework: Flask
• Components: Routes, Blueprints

Spring Boot:

• Indicators: pom.xml or build.gradle, Application.java
• Framework: Spring Boot
• Components: Controllers, Services, Repositories

Frontend Projects

React:

• Indicators: package.json with react, .jsx or .tsx files
• Framework: React
• Components: Functional components, Hooks, Context

Vue:

• Indicators: package.json with vue, vue.config.js, .vue files
• Framework: Vue 3
• Components: Single File Components, Composition API

Angular:

• Indicators: angular.json, package.json with @angular
• Framework: Angular
• Components: Components, Services, Modules

Next.js:

• Indicators: next.config.js, pages/ directory
• Framework: Next.js (React)
• Components: Pages, API routes, Components

Svelte:

• Indicators: svelte.config.js, .svelte files
• Framework: Svelte
• Components: Svelte components

Full-Stack Projects

Indicators:

• Both frontend and backend markers present
• Monorepo structure (apps/, packages/, workspaces)
• Multiple package.json files

Infrastructure Projects

Terraform:

• Indicators: .tf files
• Type: Infrastructure as Code
• Resources: Providers, Modules, Resources

Kubernetes:

• Indicators: .yaml files with kind:, apiVersion:
• Type: Container orchestration
• Resources: Pods, Services, Deployments

Docker:

• Indicators: Dockerfile, docker-compose.yml
• Type: Containerization
• Resources: Services, Images, Networks

Ansible:

• Indicators: playbook.yml, ansible.cfg
• Type: Configuration management
• Resources: Playbooks, Roles, Tasks

Library/Package Projects

Python Package:

• Indicators: setup.py, pyproject.toml without web framework
• Type: Library
• Structure: Package with init.py

JavaScript/TypeScript Library:

• Indicators: package.json with "main" field, no web framework
• Type: Library
• Structure: Exported modules

Rust Crate:

• Indicators: Cargo.toml, src/lib.rs
• Type: Library
• Structure: Cargo package

Go Package:

• Indicators: go.mod, package structure
• Type: Library
• Structure: Go module

Detection Method:

# Use Glob to find indicator files
Glob: "manage.py"  # Django
Glob: "main.py"    # FastAPI
Glob: "package.json"  # Node.js

# Use Read to check file contents
Read: "package.json"  # Check dependencies

# Use Grep to find specific patterns
Grep: pattern="from django" glob="*.py"  # Django imports
Grep: pattern="from fastapi" glob="*.py"  # FastAPI imports

Step 3: Generate README.md

Create comprehensive README based on project type using template.

README Sections (adapt based on project type):

1. Project Header

   • Project name (from directory or package.json/setup.py)
   • Brief description (placeholder for user to fill)
   • Badges (build status, coverage - placeholders)

2. Overview

   • What the project does
   • Key features (placeholder with examples)
   • Technology stack (detected technologies)

3. Installation

   • Prerequisites (based on project type)
   • Installation steps (framework-specific)
   • Environment setup

4. Usage

   • Quick start example
   • Common commands (framework-specific)
   • Configuration options

5. Project Structure

   • Directory tree (generated from actual structure)
   • Key directories explanation

6. Development

   • Setup development environment
   • Running tests (framework-specific commands)
   • Code style guidelines

7. API Documentation (for backend projects)

   • Link to detailed API docs
   • Example endpoints

8. Deployment (if applicable)

   • Deployment prerequisites
   • Deployment steps
   • Environment variables

9. Contributing

   • Link to CONTRIBUTING.md
   • Basic contribution workflow

10. License

    • License type (detect from LICENSE file or placeholder)

Use template: templates/README.template.md with placeholders replaced

Step 4: Create docs/ Directory Structure

Generate standard documentation directory:

docs/
├── architecture.md
├── api.md (for backend/full-stack)
└── .gitkeep (if empty)

Step 5: Generate architecture.md

Create architecture documentation using template.

Architecture Sections (adapt based on project type):

1. System Overview

   • High-level description
   • Main components
   • Technology choices

2. Architecture Diagram (Mermaid placeholder)

   • Component diagram
   • Data flow diagram
   • Deployment diagram (for infrastructure)

3. Components

   • Component 1: Description
   • Component 2: Description
   • (Based on detected project structure)

4. Data Flow

   • Request/response flow (backend)
   • State management flow (frontend)
   • Resource provisioning (infrastructure)

5. Technology Stack

   • Languages
   • Frameworks
   • Libraries
   • Infrastructure

6. Design Decisions

   • Key architectural choices (placeholders)
   • Trade-offs considered

Use template: templates/architecture.template.md

Step 6: Generate api.md (Backend/Full-Stack Only)

Create API documentation template.

API Documentation Sections:

1. Overview

   • API base URL (placeholder)
   • Authentication method (detect or placeholder)
   • Response format (JSON, XML, etc.)

2. Authentication

   • Auth type (JWT, OAuth, API Key)
   • How to authenticate
   • Example auth request

3. Endpoints

   • Table of endpoints (detect from code or placeholders)
   • Method | Endpoint | Description
   • Request/response examples

4. Error Handling

   • Error response format
   • Common error codes

5. Rate Limiting (if applicable)

   • Rate limit rules
   • Headers

Use template: templates/api.template.md

Step 7: Create Directory Structure Visual

Generate directory tree for README using Bash:

# Generate tree (if tree command available)
tree -L 3 -I 'node_modules|__pycache__|*.pyc|.git'

# Or use find
find . -type d -maxdepth 3 | grep -v node_modules | grep -v __pycache__

Insert into README.md

Step 8: Populate Placeholders

Replace template placeholders with detected values:

Replacements:

• {{PROJECT_NAME}}: From directory name, package.json, setup.py
• {{DESCRIPTION}}: Placeholder or from package.json
• {{FRAMEWORK}}: Detected framework (Django, React, etc.)
• {{LANGUAGE}}: Detected language (Python, JavaScript, etc.)
• {{INSTALL_COMMAND}}: Framework-specific (pip install, npm install)
• {{RUN_COMMAND}}: Framework-specific (python manage.py runserver, npm start)
• {{TEST_COMMAND}}: Framework-specific (pytest, npm test)

Step 9: Report Creation

After creating files, report to user:

# Documentation Bootstrap Complete ✅

## Created Files
- README.md (X lines)
- docs/architecture.md (Y lines)
- docs/api.md (Z lines) [if applicable]

## Project Type Detected
- Type: [Django Backend / React Frontend / etc.]
- Framework: [framework name]
- Language: [language]

## Next Steps
1. Review generated documentation
2. Fill in placeholders marked with [PLACEHOLDER] or {{VARIABLE}}
3. Add project-specific details
4. Update Mermaid diagrams with actual architecture
5. Add real API endpoint examples

## Customization Needed
- [ ] Add project description in README.md
- [ ] Fill technology stack details
- [ ] Add real API endpoints in docs/api.md
- [ ] Update architecture diagram
- [ ] Add deployment instructions
- [ ] Update environment variables

Templates

Templates are located in skills/docs-bootstrapper/templates/:

1. README.template.md: Main README template
2. architecture.template.md: Architecture doc template
3. api.template.md: API documentation template

Templates use placeholders:

• {{VARIABLE}}: Auto-replaced with detected values
• [PLACEHOLDER]: User must fill in
• [OPTIONAL]: Optional section, can be removed

Integration with Other Skills

• docs-manager: Invokes bootstrapper when no docs exist
• docs-analyzer: Identifies when bootstrapping is needed
• mermaid-expert: Called after bootstrapping to fill diagram placeholders

Example Usage

Scenario 1: New Django Project

User: /docs-bootstrapper

docs-bootstrapper:
Checking existing documentation...
No comprehensive docs found.

Detecting project type...
✓ Detected: Django Backend
✓ Framework: Django 4.2 + DRF
✓ Database: PostgreSQL (from settings)

Creating documentation...
✓ README.md created (180 lines)
✓ docs/architecture.md created (120 lines)
✓ docs/api.md created (90 lines)

Bootstrap complete! Review and customize generated docs.

Scenario 2: React Project

User: Bootstrap documentation for this React app

docs-bootstrapper:
Detecting project type...
✓ Detected: React Frontend
✓ Framework: React 18 + TypeScript
✓ State: Redux Toolkit

Creating documentation...
✓ README.md created (160 lines)
✓ docs/architecture.md created (100 lines)

Bootstrap complete! Frontend project detected, no API docs generated.

Guidelines

Do:

• ✅ Detect project type accurately
• ✅ Use appropriate templates for project type
• ✅ Generate realistic directory structures
• ✅ Provide clear placeholders for user input
• ✅ Report what was created
• ✅ Give next steps guidance

Don't:

• ❌ Overwrite existing comprehensive documentation
• ❌ Make assumptions about business logic
• ❌ Generate fake/incorrect API endpoints
• ❌ Include overly generic content
• ❌ Skip project type detection
• ❌ Create docs without user awareness

Standalone Usage

Can be invoked directly when starting new projects:

User: /docs-bootstrapper

Skill: Detects project, creates comprehensive documentation structure

Or called by docs-manager when gap analysis shows no docs exist.