Loading...
Loading...
Found 44 Skills
Ruthless complexity killer. Challenges every abstraction, layer, and pattern with "can you do this with 1/10th the complexity?" Roasts over-engineering and forces the simplest solution that works.
System Architect that creates parallelizable PRDs with junior-proof technical specs. Use when planning features, designing implementations, or when the user says 'plan', 'architect', 'design', or 'PRD'. Outputs PRDs organized in Priority groups where tasks within each group can be executed in parallel by independent dev subagents (ralph). Each user story includes file ownership, technical specs, and acceptance criteria detailed enough for a Sonnet-class model to implement without clarification.
Scan and analyze a software repository or project for design quality using principles from A Philosophy of Software Design by John Ousterhout. Use when user asks to review, audit, scan, or evaluate code quality, design quality, architecture, or technical debt. Also trigger for: code review, design review, complexity analysis, code health check, module depth analysis, information hiding review, how good is my code, review my project, find design problems, what is wrong with my codebase, rate my code, or anything about evaluating software design quality at a structural level. This is not a linter or style checker. It evaluates deep design qualities like module depth, abstraction quality, information hiding, and complexity patterns.
When writing or reviewing code to prevent over-engineering and speculative features. Use when the user says "is this over-engineered," "do we need this," "should I add," "future-proof," or "just in case." For simplicity concerns, see kiss. For abstraction design, see solid.
Use when a request asks for software design patterns or design principles, including explanations, comparisons, summaries, or quick reference grounded in local docs.
Investigates and analyzes an idea or codebase area before committing to changes. Pure research, no writes. Trigger: /sdd-explore <topic>, explore, investigate codebase, research feature, analyze before changing.
Design a module's interface using parallel sub-agents producing radically different designs ("design it twice"). Compare on depth, simplicity, and efficiency. Embedded grill on the synthesized choice. Use when designing a new API, exploring interface options, or deciding the shape of a refactor before writing code.
Comprehensive knowledge of all 23 Gang of Four design patterns with progressive disclosure (Quick/Practical/Deep), pattern recognition for problem-solving, and philosophy-aligned guidance to prevent over-engineering.
Use when designing, reviewing, refactoring, or implementing code that should stay simple, testable, readable, and sustainable. Applies principles for investigating before changes, keeping few layers, making I/O explicit, using dependencies deliberately, organizing by feature, naming consistently, and presenting plans progressively.
Design architecture for Ark features following existing patterns and principles. Use when planning new features, extending components, or evaluating technical approaches.
Diagnoses what makes code complex and why, using the three-symptom two-root-cause framework. Use when code feels harder to work with than it should but the specific problem is unclear. This skill identifies WHETHER complexity exists and WHERE it comes from. Not for scanning a checklist of known design smells (use red-flags) or evaluating a specific module's depth (use deep-modules).
Create well-structured RFCs and technical proposals for software projects. Use this skill whenever the user wants to write an RFC, technical proposal, design doc, architecture doc, or system design overview. Also trigger when the user says things like "write an RFC", "I need to propose a new system", "create a technical proposal", "document the architecture", "write up the design", "I need a design doc", or "explain the system architecture in a doc". Even if they just say "RFC", "design doc", or "arch doc", use this skill. Covers both RFCs (proposing what to build) and architecture docs (documenting an existing codebase).