c3-component-design

Document leaf-level C3 components with frontmatter, contract, and interface diagrams.

12|2|Updated Nov 21, 2025
One-click install
npx skills add https://github.com/lagz0ne/c3-skill --skill c3-component-design
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: c3-component-design
Source: https://github.com/lagz0ne/c3-skill/tree/main/skills/c3-component-design
Command: npx skills add https://github.com/lagz0ne/c3-skill --skill c3-component-design

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill guides developers in documenting the lowest level of architecture (Component), focusing on implementation details, configuration, and technical specifics. It ensures that component documentation is precise, adheres to higher-level architectural constraints, and remains relevant over time.

Core Features & Use Cases

  • Inherits Full Hierarchy: Automatically loads and verifies constraints from both the parent Container and the overarching Context layer.
  • Content Longevity Principles: Emphasizes documenting generic patterns over specific code, and flows over exhaustive implementation details, to keep documentation stable.
  • Critical Decision Framework: Helps determine if a change is truly contained within the component or requires escalation to higher architectural layers.
  • Determines Component Nature: Identifies if a component is a resource integration, business logic, or framework entrypoint to tailor documentation focus.
  • Socratic Discovery: Uses targeted questions to elicit details about configuration, behavior, error handling, and usage patterns.
  • Use Case: A developer needs to document a new database connection pool component. This skill helps them detail its configuration, error handling, and usage patterns, ensuring it aligns with the container's technology stack and the system's cross-cutting concerns.

Quick Start

Use the c3-component-design skill to document the new user authentication component.

Frequently Asked Questions about c3-component-design

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I document a component's configuration and dependencies in C3 architecture?

Component documentation in C3 architecture requires detailing configuration, dependencies, and implementation specifics while enforcing a diagram-first approach. Start by verifying the component aligns with its parent container, then generate documentation with frontmatter, contract, interface diagram, hand-offs table, conventions table, and edge-cases table to standardize technical details.

What should be included in a leaf-level component's documentation?

Leaf-level component documentation must include frontmatter, parent container contract, a required interface diagram, hand-offs table describing external interactions, conventions table for patterns and standards, and edge-cases table for error handling and boundary conditions. This standardized structure ensures precision and architectural alignment.

How do I verify a component aligns with its parent container's constraints?

Component verification loads constraints from both the parent container and context layers to ensure alignment. During component exploration, confirm the component is listed in its parent, validate its nature (resource integration, business logic, or framework entrypoint), and cross-check configuration against inherited architectural requirements.

When should I document implementation details versus generic patterns in component documentation?

Document generic patterns and flows rather than exhaustive implementation details to maintain documentation longevity. Focus on configuration behavior, error handling, and usage patterns that remain stable over time, while deferring code-specific details that change frequently.

How do I determine if a component change requires escalation to higher architectural layers?

Use a critical decision framework to assess whether a change is truly contained within the component or affects the container or context layers. If the change impacts technology stack alignment, cross-cutting concerns, or parent constraints, escalate; otherwise, document it as a contained component modification.

What's the difference between resource integration, business logic, and framework entrypoint components?

Component nature determines documentation focus: resource integration components detail external system connections and configuration; business logic components emphasize decision flows and error handling; framework entrypoint components highlight initialization, dependencies injection, and lifecycle management. Identifying the component type tailors documentation specificity.