Skill UI

A comprehensive assistant designed to analyze existing codebases for adherence to SOLID principles, common code smells, and complexity metrics. It identifies anti-patterns like tight coupling, excessive responsibility, and duplication, providing prioritized, actionable refactoring suggestions to improve code maintainability and quality.

A comprehensive, stack-agnostic tool for deeply evaluating agent harnesses. It checks for broken code paths, redundant instructions, and the overall usefulness of agent logic using a structured, multi-stage dual-judge protocol. The process involves high-priority questionnaires (Q1, Q2) before running three defined tracks: A (Correctness), B (Redundancy), and C (Usefulness). Ideal for auditing complex agent systems before deployment or major refactoring.

A systematic approach to restructuring code while guaranteeing that the external behavior remains identical. This methodology is crucial for large-scale changes, such as feature extraction, consolidation of logic, or complex ownership moves, where robust verification must bracket every structural edit.

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 skill enables applying John Ousterhout's design principles to reduce complexity in software systems. It guides decisions on module boundaries, API design, information hiding, and abstraction depth. Use it when refactoring shallow interfaces or managing cognitive load during development. Ideal for architects and senior engineers optimizing system structure and ensuring maintainable codebases through proper abstraction layers.

Apply Martin Fowler-inspired refactoring rules to improve existing code structure while preserving observable behavior. Covers code smells, small safe refactoring steps, test-backed cleanup, and separating refactoring from feature changes.

This skill applies Refactoring.Guru-inspired rules for diagnosing code smells and selecting appropriate refactoring techniques. It helps preserve behavior while avoiding uncontrolled redesign. Before making design or code decisions, read the mini rules first. Use the full guide only as a deeper reference when needed. It ensures targeted cleanup without over-engineering.

This skill allows delegating self-contained coding tasks to assistants like Codex or Claude Code via non-interactive background processes. It supports feature development, code review, and refactoring. Use OpenSquilla's exec_command and process tools to manage sessions, poll output, and send inputs without blocking the main workflow. Ideal for tasks requiring substantial file exploration.

A set of behavioral guidelines derived from Andrej Karpathy's observations to help users writing, reviewing, or refactoring code with Large Language Models (LLMs). It guides developers to avoid overcomplication, make surgical changes, explicitly surface assumptions, and define verifiable success criteria, promoting clean, simple, and robust code development.

This skill provides a comprehensive guide for optimizing Angular applications. It covers performance bottlenecks, bundle size reduction, and rendering efficiency. Use it when writing, reviewing, or refactoring Angular code to ensure optimal speed and load times.

This skill provides expertise in proven backend architectural patterns, including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design (DDD). It guides users in building highly maintainable, testable, and scalable systems. Use it when designing new services, refactoring complex monoliths, establishing team standards, or planning microservice decompositions. It emphasizes defining clear boundaries and handling complex, durable workflows.

This skill performs a comprehensive architecture audit on codebases by mapping module dependencies and checking layering integrity. It identifies structural decay using principles from classic engineering books. The tool generates Mermaid dependency graphs, assesses testability seams, and applies Conway's Law checks to ensure architectural health. It is suitable for developers needing to understand codebase structure, review folder organization, or detect circular imports before refactoring.