Skill UI

A meta-skill that evaluates task complexity, selects and combines appropriate skills from local or catalog sources, records successful skill combinations via agent-memory-mcp, and guards against over-engineering simple tasks.

This skill simplifies and refines code to enhance clarity, consistency, and maintainability without altering functionality. It applies project-specific best practices to improve readability, reduce complexity, and align with coding standards. Ideal for cleaning up recently modified code or optimizing existing logic for better structure.

This skill helps identify technical debt within software codebases by analyzing code and change history. It estimates the impact of debt items and prioritizes improvements based on ROI. Users can generate actionable remediation plans, assess risks, and track metrics like code complexity and test coverage to maintain software quality and development velocity.

A structured playbook for improving the time and space complexity (Big-O) of existing, slow code. This skill guides developers through systematic refactoring, focusing on identifying bottlenecks like nested loops or N+1 queries. It emphasizes applying transformations one at a time, maintaining test coverage, and measuring performance gains to ensure correct and efficient code.

idea-os is a comprehensive, five-phase pipeline designed to transform a raw, abstract idea into a fully structured, build-ready plan. It guides users through Triage, Clarification, Deep Research, detailed PRD creation (including non-goals and metrics), and finally, a phased execution plan. The system adapts its complexity and vocabulary to the user's sophistication level, providing everything from foundational market analysis to actionable technical stack recommendations.

This skill enforces an algorithm-first discipline, requiring the user to state the time and space complexity (Big-O), the intended data structure, and the core algorithm family before writing any complex code (loops, queries, recursion). It serves as a critical gatekeeper to prevent common performance pitfalls like O(n²) complexity, N+1 database queries, and brute-force implementation errors, significantly improving code robustness and efficiency.

This skill acts as an ultra-advanced mathematician inspired by Terence Tao. It performs rigorous code and architecture analysis using deep mathematical theories such as information theory, graph theory, computational complexity, linear algebra, stochastic analysis, category theory, Bayesian probability, and formal logic. Ideal for complex algorithmic verification and architectural design review.

A specialized skill for achieving asymptotic performance gains when classical algorithms are already near optimal. It leverages advanced mathematical techniques and probabilistic data structures (e.g., Bloom Filters, HyperLogLog, FFT, MinHash/LSH) to handle massive datasets (n ≥ 10⁶) by accepting bounded approximations or exploiting deep structural properties. Requires strict adherence to error parameter and complexity justification protocols.

A specialized skill designed for agents to proactively identify, analyze, and strategize high-impact contributions within trending Open Source repositories. It systematically performs repository discovery, extracts targeted issues (like 'help wanted' or 'good first issue'), and conducts deep feasibility analysis (including mergeability and complexity). Finally, it generates a structured 'Contribution Dossier' with actionable plans, significantly accelerating the process of becoming a top-tier OSS contributor.

A critical discipline for managing expenses when integrating paid AI or inference APIs. This guard treats dollar cost as a third complexity dimension, mandating the definition of cost contracts (max calls per run, max budget per run, max budget per day). It enforces best practices for bounding loops, retries, and fan-out, ensuring that code bugs cannot lead to unexpected overspending. Best practice requires configuring hard caps both in the code and at the provider dashboard for defense in depth.

Analyzes existing Rails applications to provide a comprehensive and detailed upgrade assessment. This tool checks current gem and JavaScript dependencies, compares the running version against the latest stable release, fetches official upgrade guides, and generates diff reports. It assesses upgrade complexity (Small, Medium, Large) to ensure smooth and safe version migration for Ruby on Rails projects.

This skill analyzes your opencode prompt history to identify repeating multi-step workflows, recurring unmet needs, and candidates for new reusable skills. By scoring patterns based on frequency, complexity, and tool usage, it helps users save time and avoid repeating complex manual tasks.