Reverse Documentation

Reverse Documentation Skill

Automatically generate comprehensive documentation for Rust and TypeScript codebases by analyzing existing code structure, patterns, and relationships.

When to use

Use this skill when you need to:

• Generate comprehensive API documentation for Rust crates
• Document React components and custom hooks
• Create architecture documentation from code analysis
• Generate migration guides for API changes
• Create README and implementation guides
• Document design patterns and relationships
• Build code examples and tutorials
• Cross-reference related functionality

Core concepts

Rust Documentation

This skill understands and documents:

• Module Organization: Workspace structure, crate dependencies, feature flags
• Types & Traits: Struct, enum, and trait definitions with full type signatures
• Error Handling: Result types, custom error types, error propagation patterns
• Async Patterns: Tokio-based async functions, futures, task spawning
• Generic Types: Type parameters, bounds, and lifetime annotations
• Implementation Details: Methods, associated functions, trait implementations
• Testing: Unit tests, integration tests, documentation examples

TypeScript Documentation

This skill understands and documents:

• Module Structure: Exports, re-exports, and module dependencies
• Type Definitions: Interfaces, types, generics, and utility types
• React Components: Functional components, props, state, lifecycle
• Custom Hooks: Hook composition, state management, side effects
• API Integration: Data fetching, request/response types, error handling
• State Patterns: useState, useReducer, Context API, state management libraries
• Next.js Patterns: Pages, layouts, API routes, middleware, server components

Quick start

For Rust codebases

Generate comprehensive documentation for the [crate-name] crate

Document the trait-based storage abstraction in edgequake-storage

Create API documentation for all public interfaces with examples

For TypeScript codebases

Generate documentation for all React components in src/components

Document the custom hooks in src/hooks with usage examples

Create type documentation for the API integration layer

Capabilities

Rust Capabilities

1. Crate Documentation

• Analyze Cargo.toml and workspace structure
• Extract and document all public types, traits, and functions
• Generate comprehensive README files
• Create architecture diagrams of trait relationships
• Document feature flags and optional dependencies

2. API Reference Generation

• Extract function signatures with parameters and return types
• Document error types and handling patterns
• Include working code examples
• Show generic type usage
• Cross-reference related types

3. Pattern Documentation

• Identify and document design patterns (Builder, Factory, Strategy, etc.)
• Explain async/await patterns and tokio usage
• Document error handling approaches
• Show trait implementations and polymorphism
• Explain generic type usage

4. Example Generation

• Create working code examples for public APIs
• Show error handling patterns
• Demonstrate async operations
• Include edge cases and common pitfalls

TypeScript Capabilities

1. Component Documentation

• Extract component props with types and defaults
• Document component behavior and event handlers
• Generate prop combinations and variants
• Create Storybook stories
• Show component composition patterns

2. Hook Documentation

• Document hook parameters and return values
• Show hook composition patterns
• Explain dependency arrays
• Include usage examples
• Identify potential performance issues

3. Type Documentation

• Extract and document all exported types and interfaces
• Show generic type parameters
• Document utility type usage
• Create type hierarchy diagrams
• Show API request/response types

4. Architecture Documentation

• Generate data flow diagrams
• Document state management patterns
• Show API integration patterns
• Identify dependency trees
• Document component hierarchies

Workflow

When you invoke this skill, the AI assistant will:

1. Discovery Phase: Scan the codebase to find files and understand structure
2. Analysis Phase: Parse code to extract types, functions, patterns, and relationships
3. Understanding Phase: Identify design patterns, architectural decisions, and key concepts
4. Generation Phase: Create comprehensive documentation in your chosen format
5. Validation Phase: Verify examples compile and documentation is complete

Output formats

Markdown Documentation

• Module-level README files
• API reference documentation
• Architecture documentation
• Migration guides
• Best practices guides

Inline Documentation

• Rust doc comments (/// and //!)
• TypeScript JSDoc comments
• Follow language conventions
• Include examples and sections

Diagrams

• Trait relationship diagrams (Mermaid)
• Component hierarchy diagrams
• Data flow diagrams
• Module dependency graphs

Storybook Stories (TypeScript)

• Component prop variations
• Interactive examples
• Usage patterns
• Edge cases

Configuration options

Customize documentation generation:

# Scope of documentation
scope: "public"           # or "all" for private items too

# Output format
format: "markdown"        # or "inline" or "both"

# Include sections
include_examples: true
include_tests: true       # Rust only
include_diagrams: true
include_stories: true     # TypeScript only

# Documentation depth
depth: "comprehensive"    # or "brief" or "detailed"

# Target audience
audience: "developers"    # or "maintainers" or "contributors"

Best practices

Rust Documentation

• ✅ Document all public APIs
• ✅ Include working code examples that compile
• ✅ Show error cases and how to handle them
• ✅ Explain generic type parameters and constraints
• ✅ Document async/await usage and tokio requirements
• ✅ Cross-reference related types and traits

TypeScript Documentation

• ✅ Document all component props with types
• ✅ Show component prop variations
• ✅ Explain hook return values and side effects
• ✅ Document data flow and state management
• ✅ Include usage examples with actual code
• ✅ Document performance considerations

EdgeQuake-specific patterns

Rust

• Multi-crate Workspace: edgequake-core, edgequake-storage, edgequake-llm, edgequake-api
• Trait Abstraction: GraphStorage, LLMProvider, StorageAdapter traits
• Error Handling: Custom StorageError, PipelineError types
• Async Pipeline: Document the entity extraction and graph building pipeline
• Entity Normalization: Special naming conventions (e.g., "SARAH_CHEN")

TypeScript

• Next.js 15 App Router: Document pages, layouts, and API routes
• shadcn/ui Components: Document UI component composition
• Data Fetching: SWR hooks and API integration patterns
• Form Handling: react-hook-form patterns
• State Management: Workspace, query, and document state patterns
• Streaming: SSE and streaming response handling

Examples

Rust Example

Generate comprehensive documentation for the edgequake-storage crate including:
- All trait definitions and implementations
- Storage backend comparison (Memory vs PostgreSQL)
- Error handling patterns
- Async operation patterns
- Integration tests
- Architecture diagram showing trait relationships

TypeScript Example

Generate documentation for the edgequake_webui components including:
- All React components with props
- Custom hooks in src/hooks
- API integration types
- Component composition examples
- Storybook stories for all components
- Data flow diagram

Troubleshooting

Documentation not generating

• ✓ Ensure files are accessible and readable
• ✓ Check file permissions
• ✓ Verify syntax is valid

Examples don't compile (Rust)

• ✓ Test examples before including them
• ✓ Ensure all imports are present
• ✓ Verify types are correct and in scope

Missing documentation

• ✓ Check if items are public/exported
• ✓ Verify exports are in correct module
• ✓ Ensure items are accessible from public API

Related skills

• makefile-dev-workflow: Development workflow commands
• playwright-ux-ui-capture: UI screenshot capture automation
• ux-ui-analyze-single-page: Single page UX analysis

See also

• Rust Book - Documentation
• TypeScript Documentation
• React Documentation
• Rust API Guidelines