Loading...
Loading...
Found 47 Skills
Apply the K.I.S.S principle (Keep It Simple, Stupid) to reduce complexity, improve maintainability, and solve problems elegantly. Use when designing systems, writing code, planning solutions, creating documentation, architecting features, or making decisions where simplicity drives quality and efficiency.
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.
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.
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.
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.
使用 parallel sub-agents 为 module 生成多个 radically different interface designs。Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".
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.
Turn ideas into fully formed designs and specs through natural collaborative dialogue. Use when planning new features, designing architecture, or making significant changes to the codebase.
Reviews error handling strategy and exception design. Use when the user asks to review error handling, when a module throws too many exceptions, or when callers must handle errors they shouldn't need to know about. Applies the "define errors out of existence" principle with a decision tree for exception strategies.
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).
Design architecture for Ark features following existing patterns and principles. Use when planning new features, extending components, or evaluating technical approaches.
Software design principles and patterns. This skill should be used when making architectural decisions, designing classes or modules, or evaluating code structure. Use proactively when discussing SOLID principles, coupling, cohesion, connascence, refactoring structure, class design, module boundaries, dependency injection, or the Four Rules of Simple Design. (user)