oo-component-documentation
github/awesome-copilot
Create or update standardized OO component documentation using shared templates and mode-specific guidance.
What is oo-component-documentation?
This skill generates or refreshes object-oriented component documentation by analyzing source code or existing docs. It applies C4 Model, Arc42, and IEEE 1016 standards to produce developer-focused documentation that matches the actual implementation.
- Determine whether to create new documentation from source code or update existing documentation files
- Analyze class structures, inheritance, composition, interfaces, and design patterns in OO code
- Generate standardized documentation following C4 Model, Arc42, and IEEE 1016 standards
- Document public APIs, interfaces, dependencies, parameters, return values, and lifecycle concerns
- Produce Markdown output with clear hierarchy, tables, code examples, and Mermaid diagrams
- Identify and explicitly document gaps, limitations, and unsupported sections
How to install oo-component-documentation
npx skills add https://github.com/github/awesome-copilot --skill oo-component-documentation- Access to source code files or an existing documentation file to analyze
- Understanding of whether the task is creating new docs (from code) or updating existing docs
How to use oo-component-documentation
- 1.Determine the mode: use update mode if you have an existing documentation file; use create mode if you have source code or a component path
- 2.Provide either the source code/component path (create mode) or the existing documentation file path (update mode)
- 3.The skill will analyze the implementation and generate or revise documentation using the shared template
- 4.Review the output for accuracy, diagrams, examples, and any explicitly documented gaps
- 5.Iterate if needed to refine sections or add missing architectural context
Use cases
- Generate comprehensive documentation for a new component from its source code
- Update existing component documentation to reflect recent code changes and refactoring
- Document architectural decisions, design patterns, and integration points for a class or module
- Create standardized API documentation for a component's public interfaces and methods
- Refresh documentation for language-specific patterns (async/await in C#, Spring annotations in Java, etc.)
- Software developers writing or maintaining component documentation
- Technical leads standardizing documentation across a codebase
- Architects documenting component boundaries and relationships
- Teams adopting C4 Model or Arc42 documentation standards
oo-component-documentation FAQ
Use create mode when you have source code or a component path and need to generate documentation from scratch. Use update mode when you have an existing documentation file that needs to be refreshed or revised based on current code.
The skill applies C4 Model (Context, Containers, Components, Code), Arc42 software architecture template, IEEE 1016 Software Design Description standard, and Agile Documentation principles, targeting developers and maintainers.
It includes language-specific optimizations for C#/.NET (async/await, dependency injection), Java (Spring framework, annotations), TypeScript/JavaScript (modules, async patterns), and Python (packages, type hints, testing).
The skill explicitly documents gaps and limitations rather than inventing unsupported behavior, and suggests likely locations to inspect next.
Markdown with clear heading hierarchy, tables, code blocks with real examples matching the implementation, and Mermaid diagrams for architecture relationships.
Full instructions (SKILL.md)
Source of truth, from github/awesome-copilot.
name: oo-component-documentation description: 'Create or update standardized object-oriented component documentation using a shared template plus mode-specific guidance for new and existing docs.'
OO Component Documentation
Create new documentation for an object-oriented component or update an existing component documentation file by analyzing the current implementation.
Determine the mode first
Choose the workflow before writing anything:
- Use update mode when the user provides an existing documentation Markdown file, points to a docs path, or explicitly asks to refresh or revise existing documentation. Follow references/update-mode.md.
- Use create mode when the user provides a source file or folder, points to a component path, or asks to generate documentation from code. Follow references/create-mode.md.
- If both code and an existing documentation file are provided, treat the existing documentation file as the output target and use the current source code as the source of truth.
- If the request is ambiguous, infer the mode from the path type whenever possible: existing Markdown documentation file means update mode; source/component path means create mode.
Documentation standards
- DOC-001: Follow C4 Model documentation levels (Context, Containers, Components, Code)
- DOC-002: Align with Arc42 software architecture documentation template
- DOC-003: Comply with IEEE 1016 Software Design Description standard
- DOC-004: Use Agile Documentation principles (just enough documentation that adds value)
- DOC-005: Target developers and maintainers as the primary audience
Shared analysis guidance
- ANA-001: Determine the primary component boundary and whether the input represents a folder, file, or existing documentation target
- ANA-002: Examine source code files for class structures, inheritance, composition, and interfaces
- ANA-003: Identify design patterns, architectural decisions, and integration points
- ANA-004: Document or refresh public APIs, interfaces, dependencies, and usage patterns
- ANA-005: Capture method parameters, return values, asynchronous behavior, exceptions, and lifecycle concerns
- ANA-006: Assess performance, security, reliability, maintainability, and extensibility characteristics
- ANA-007: Infer data flow, collaboration patterns, and relationships with surrounding components
- ANA-008: Keep the documentation grounded in the implementation; avoid inventing behavior that is not supported by the code
Shared output requirements
- Use assets/documentation-template.md as the canonical section checklist and baseline structure.
- Keep the output in Markdown with a clear heading hierarchy, tables where useful, code blocks for examples, and Mermaid diagrams when architecture relationships need to be visualized.
- Make examples and interface descriptions match the current implementation instead of generic placeholders.
- Include only information that can be supported by the code, project structure, configuration, or clearly stated assumptions.
- When source coverage is incomplete, document the limitation explicitly instead of guessing.
Language-specific optimizations
- LNG-001: C#/.NET - async/await, dependency injection, configuration, disposal, options patterns
- LNG-002: Java - Spring framework, annotations, exception handling, packaging, dependency injection
- LNG-003: TypeScript/JavaScript - modules, async patterns, types, npm dependencies, runtime boundaries
- LNG-004: Python - packages, virtual environments, type hints, testing, dependency management
Error handling
- ERR-001: If the path does not exist, explain what path was expected and whether the skill needs a source path or an existing documentation file
- ERR-002: If no relevant source files are found, document the gap and suggest the likely locations to inspect next
- ERR-003: If the documentation target cannot be inferred from the request, state the ambiguity and ask for the missing path only when inference is not possible
- ERR-004: If the code uses non-standard architectural patterns, document the custom approach rather than forcing it into a generic pattern
- ERR-005: If source access is incomplete, continue with available evidence and clearly call out any unsupported sections
Workflow
- Determine whether the task is create mode or update mode.
- Inspect the component implementation and any related files needed to understand its public surface area and internal structure.
- Use assets/documentation-template.md as the shared documentation scaffold.
- Apply the mode-specific rules in references/create-mode.md or references/update-mode.md.
- Produce or revise the documentation so that diagrams, examples, interfaces, dependencies, and quality attributes reflect the current implementation.
Completion criteria
- The documentation clearly identifies the component purpose, architecture, interfaces, implementation details, usage patterns, quality attributes, and references.
- Front matter fields are accurate for the selected mode.
- Examples and diagrams match the implementation.
- Any unknowns, gaps, or assumptions are explicitly called out.
Related skills
More from github/awesome-copilot and the wider catalog.

openapi-to-application-code
Generate production-ready applications from OpenAPI specifications with framework conventions and best practices.

pdftk-server
Command-line PDF manipulation: merge, split, encrypt, fill forms, watermark, and more.

penpot-uiux-design
Create professional UI/UX designs in Penpot with MCP tools and proven design principles.

phoenix-cli
Debug LLM applications using the Phoenix CLI. Fetch traces, analyze errors, structure trace review with open coding and axial coding, inspect datasets, review experiments, query annotation configs, and use the GraphQL API. Use whenever the user is analyzing traces or spans, investigating LLM/agent failures, deciding what to do after instrumenting an app, building failure taxonomies, choosing what evals to write, or asking "what's going wrong", "what kinds of mistakes", or "where do I focus" — even without naming a technique.

phoenix-evals
Build and run evaluators for AI/LLM applications using Phoenix.

phoenix-tracing
OpenInference semantic conventions and instrumentation for Phoenix AI observability. Use when implementing LLM tracing, creating custom spans, or deploying to production.