applying-code-principles

SOLID principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion—guide class and module design. This Skill evaluates when to apply each principle based on your project's safety and simplicity priorities, helping you make informed refactoring and architectural decisions without over-engineering.

DRY (Don't Repeat Yourself) eliminates code duplication, but excessive abstraction creates unnecessary complexity. This Skill balances DRY with Occam's Razor and YAGNI to help you avoid premature generalization while maintaining code maintainability and safety.

YAGNI (You Aren't Gonna Need It) and Occam's Razor prioritize simplicity by avoiding speculative features and unnecessary complexity. This Skill applies these principles to code reviews, component integration, and design-pattern selection, ensuring your codebase stays minimal and focused on actual requirements.

Design-pattern selection balances safety, simplicity, and architectural fit. This Skill uses Quick Decision Questions and principle-based rationale to guide pattern choices for class redesigns and component integration, producing concrete guidance tailored to your project's constraints.

Yes. This Skill handles code reviews, refactoring planning, and complexity evaluation across multiple projects and team structures. It enforces a consistent, project-specific priority order—Safety First, YAGNI, Occam's Razor, SOLID, DRY, Miller's Law—ensuring coherent architectural decisions at scale.

When principles conflict, this Skill enforces a fixed priority: Safety First, then YAGNI, Occam's Razor, SOLID, DRY, and Miller's Law. This order resolves trade-offs consistently, ensuring safe, simple designs in code reviews and refactoring decisions.