Skill UI

This skill builds and maintains a persistent index and dependency graph for Architecture Decision Records (ADRs). It processes both v3-style and YAML plugin-style formats, storing ADR content in the `adr-patterns` namespace and relationships (like supersedes, amends, depends-on) in `adr-edges`. It is essential for synchronizing the graph when ADRs are updated, imported, or when bootstrapping ADR tracking on an existing codebase.

This tool reviews code changes (via diff) against accepted Architecture Decision Records (ADRs) to detect potential architectural drift, compliance violations, and adherence issues. It simulates a pre-merge check, ensuring that new code respects established architectural constraints and decisions made by the team. Ideal for CI/CD pipelines and mandatory code reviews.

This tool reads the persisted ADR graph to surface critical data integrity issues. It detects dangling references (links to non-existent ADRs), conflicting supersede cycles (A supersedes B and B supersedes A), and status mismatches. It is essential for CI/CD pipelines and post-indexing validation to ensure architectural decision records are consistent and reliable.

This skill helps developers structure and record critical architectural decisions (ADRs) made during coding sessions. It automatically detects moments of decision, capturing the context, alternatives considered, and the rationale (trade-offs and consequences). This maintains a living log that explains 'why' the code base was built the way it is, preventing knowledge loss and improving project maintainability.

This tool serves as a persistent memory and state manager for complex coding projects within the Claude environment. It allows users to initialize new projects with structured metadata, track detailed session progress (including summaries, decisions, and next steps), and save the entire context reliably. By ensuring project continuity across disconnected sessions, it drastically improves the flow and consistency of the development workflow.

This tool enables the definition and management of structured cognitive patterns for advanced AI agents. It guides decision-making by codifying complex reasoning strategies, including decision trees, chain of thought (CoT), and analogy mapping. Use it to build robust, self-improving agents that can solve complex problems step-by-step and track their learning status.

This skill guides the definition of a defensible and decision-relevant competitor set. It is the foundational step before any benchmarking, helping users identify, categorize, and scope competitors (Direct, Adjacent, Aspirational) based on criteria like size, niche, market reach, and positioning. It ensures that strategic analysis focuses only on the most relevant rivals.

This skill assembles scored competitor profiles and market findings into a comprehensive, decision-grade report. It guides the user to answer critical client questions: who to compete with, how to differentiate, and where the defensible white-space is. Ideal for board presentations, strategic planning, and creating highly defensible client deliverables.

This pattern defines a robust, continuous loop structure for autonomous agents. It integrates crucial components like quality gates, evaluation harnesses, and explicit recovery controls. It guides complex workflows by defining decision paths (e.g., PR control, RFC decomposition) and includes strategies to mitigate common failure modes such as infinite loop churn or cost drift, ensuring measurable progress in autonomous systems.

This skill simulates a four-voice council (Architect, Skeptic, Pragmatist, Critic) to resolve complex decisions marked by ambiguity or multiple trade-offs. It is designed for high-level strategic choices, identifying blind spots, and determining go/no-go decisions when a clear winner is absent. It specializes in synthesizing diverse perspectives to mitigate risk.

A comprehensive guide derived from C++ Core Guidelines, enforcing modern, safe, and idiomatic practices for C++17, C++20, and C++23. It emphasizes crucial principles like RAII, type safety, immutability, and proper resource ownership using smart pointers. Use this when writing new features, reviewing existing code, or making architectural decisions to ensure code quality and consistency.

This tool guides the creation of actionable monitoring dashboards for observability platforms like Grafana and SigNoz. Instead of merely displaying raw metrics, it focuses on structuring data to answer critical operational questions: Is the system healthy? Where are the bottlenecks? What changes occurred? And what action should be taken? It transforms raw metrics into decision-making tools.