Skill UI

This skill ingests public complaints from X/Twitter, automatically detecting, classifying, and clustering reported bugs. It cross-references symptoms with repository evidence (commits, deploys) and assigns ownership using defined routing rules. It is essential for product teams needing to monitor product health and gather early bug signals from social media channels.

This tool analyzes and refactors code to detect and correct anemic domain models. It enforces rich domain modeling patterns (Entities, Value Objects, Aggregates, Domain Events), improving encapsulation and business logic ownership. Use it when validating, reviewing, or refactoring core domain logic to ensure adherence to Domain-Driven Design (DDD) principles.

Provides a structured workflow for systematically accessing and analyzing official intellectual property data from the USPTO. This skill covers patent search (PatentSearch API), trademark status checks (TSDR), ownership transfer tracking, and building reproducible IP landscape logs. It is designed for data collection and record verification, emphasizing the use of official APIs and rigorous logging practices. (Warning: Not for legal advice.)

This skill helps C-level executives review contracts, term sheets, and IP agreements before signing. It surfaces six critical questions regarding IP ownership, liability caps, data privacy, termination rights, regulatory exposure, and equity grants to minimize legal risk and ensure informed business decisions.

Pressure-tests multi-framework compliance programs with six forcing questions covering framework scope, control overlap, evidence ownership, audit calendar, mock audits, and management review.

This comprehensive guide details idiomatic best practices for writing high-performance, safe code in Rust. It covers advanced topics such as understanding Ownership and Borrowing rules, robust error handling using the '?' operator, optimizing functional programming with Iterators, implementing structured concurrency, and defining robust data models with Structs and Enums.

This skill guides the decomposition of monolithic applications into independent microservices using Domain-Driven Design (DDD). It defines bounded contexts, service boundaries, communication patterns (sync/async), data ownership, and provides a structured migration roadmap (e.g., Strangler Fig Pattern). Essential for scaling and modernizing large enterprise systems.

This skill generates a comprehensive RACI (Responsible, Accountable, Consulted, Informed) matrix for complex projects, product launches, or ongoing business processes. It clarifies ownership, defines decision rights, and maps roles across cross-functional teams (R, A, C, I), ensuring accountability and preventing bottlenecks. Ideal for governance documentation or onboarding new teams.

This workflow transforms long YouTube talks and lectures into a personal, structured, and local markdown library. Each video becomes a self-contained file containing slide snapshots, full timestamped transcripts, and editable study notes. It eliminates reliance on cloud services, giving users full ownership of their academic material.

Execute discrete, bounded coding, review, or verification tasks using the Codex CLI as an isolated subagent. This tool is ideal for tasks requiring explicit file ownership, such as isolated refactoring, feature implementation, or independent code verification, without relying on continuous conversational context. It runs in a safe sandbox environment.

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 skill provides deep insights into idiomatic Rust development. It covers core concepts like ownership and borrowing to prevent data races, robust error handling using `anyhow` and `thiserror`, advanced pattern matching with enums, and utilizing traits and generics for safe abstraction. Master these patterns when writing or refactoring complex, high-performance, and reliable Rust applications.