simplicity-principles

Enforce KISS, YAGNI, and Least Astonishment principles during software design and refactoring.

187|20|Updated Nov 20, 2025
One-click install
npx skills add https://github.com/TheBushidoCollective/han --skill simplicity-principles
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: simplicity-principles
Source: https://github.com/TheBushidoCollective/han/tree/main/core/skills/simplicity-principles
Command: npx skills add https://github.com/TheBushidoCollective/han --skill simplicity-principles

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill promotes simple, predictable, and minimal designs to reduce cognitive load and maintenance costs.

Core Features & Use Cases

  • KISS: Favor simple functions over complex abstractions.
  • YAGNI: Avoid premature generalization and over-engineering.
  • Least Astonishment: Use intuitive APIs and naming.

Quick Start

Identify an over-engineered snippet and replace it with a straightforward, clearly named alternative.

Frequently Asked Questions about simplicity-principles

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I reduce over-engineered code in my design?

Over-engineered code can be simplified by applying KISS (Keep It Simple, Stupid): favor straightforward functions and direct implementations over complex abstractions. Identify unnecessary layers, remove premature generalizations, and replace them with clear, minimal solutions that are easier to test and maintain.

What's the difference between KISS and YAGNI principles?

KISS emphasizes simple, readable code with minimal moving parts. YAGNI (You Aren't Gonna Need It) prevents premature generalization and over-engineering by avoiding features you don't need now. Together, they eliminate cognitive load and reduce maintenance costs through straightforward design.

When should I refactor code for simplicity?

Refactor for simplicity during solution design, feature design, or when code becomes hard to test or debug. Apply the Principle of Least Astonishment by using intuitive naming and predictable APIs. This reduces complexity before it compounds during maintenance.

How do I know if my design follows the Principle of Least Astonishment?

The Principle of Least Astonishment ensures APIs and naming are intuitive and predictable. If other developers can understand your code's behavior without surprise or extra context, and function names clearly describe what they do, your design follows this principle.

Can I apply these simplicity principles to existing code?

Yes. Identify over-engineered snippets in existing code and replace them with straightforward, clearly named alternatives. These principles apply equally during refactoring, helping you reduce technical debt while maintaining functionality.