Skill UI

This document defines the critical architectural contract for standardizing advisory transport across diverse AI code review runtimes (e.g., Claude Code, OpenCode, Codex). It mandates that all integrations adhere to a shared Go contract, governing how review results, evidence, and validation are processed. This is essential for ensuring system integrity, managing architectural transitions, and preventing the creation of isolated, proprietary review systems.

This skill outlines a highly rigorous, receipt-driven workflow for managing defects and implementing code corrections. It guides public collaboration by enforcing strict controls over change authority, ensuring comprehensive lineage tracking, and mandating evidence-based validation. Key steps include CodeGraph impact mapping, black-box testing, and adherence to strict change budgets, ensuring every deployed change is fully traceable and robust.

Dedicated sub-agent for implementing SDD tasks from specs and design. It reads proposal, spec, design, and tasks, then writes code following the delivery strategy and persistence contract.

Archives a Specification-Driven Development (SDD) change by syncing delta specs into the main specs and moving the change folder to the archive, completing the SDD cycle. Handles artifact store modes (engram, openspec, hybrid, none) and produces a terminal archive report with final-state authority.

This specialized sub-agent is responsible for transforming high-level feature proposals and technical specifications into a formal, comprehensive 'design.md' document. It systematically captures all necessary technical details, including architectural decisions, data flow diagrams, detailed file changes, API contracts, and thorough testing strategies. Use this skill during the planning phase of any complex software change to ensure technical completeness and feasibility.

This agent is dedicated to systematically exploring technical ideas, such as new features, refactoring, or bug fixes, *before* committing to code changes. It investigates the existing codebase, analyzes current architecture, compares multiple potential approaches (including pros, cons, and effort), and generates a structured 'exploration' report with a clear recommendation and identified risks. It ensures thorough planning and risk mitigation during the design phase.

This advanced skill initializes the Software Development Documentation (SDD) context within a project. It detects the entire technical stack, conventions, testing tools, and persistence mode across all discovered projects. It then structures and persists this comprehensive context, including building a skill registry and determining the strict TDD status, ensuring a robust starting point for development.

Guides users through a complete Spec-Driven Development (SDD) cycle on their actual codebase, from exploration to archive. Interactive walkthrough with narrated phases, teaching by doing. Suitable for onboarding developers to SDD methodology.

A sub-agent skill that turns exploration findings or user input into a structured SDD change proposal, covering intent, scope, capabilities, approach, risks, and success criteria. Persists proposal.md via engram, openspec, or hybrid storage.

Sub-agent for Specification-Driven Development (SDD) research. Investigates optional questions using authorized external sources, returns evidence, gaps, and recommendations to the orchestrator.

This sub-agent is specialized in generating precise delta specifications (delta specs). It analyzes a given proposal to identify added, modified, or removed system behaviors, creating structured requirements and scenarios to document the proposed changes accurately. It follows defined conventions for persistence across various artifact storage modes (Engram, OpenSpec, Hybrid).

This sophisticated sub-agent takes comprehensive Software Design Documents (SDD), proposals, and specifications to generate a detailed, actionable task breakdown in the format of a tasks.md file. It structures the work into distinct phases (e.g., Foundation, Core Implementation, Testing, Cleanup), providing concrete, verifiable, and small units of work suitable for immediate engineering execution and managing complex feature delivery chains.