skills.rest
Tromml
TrommlOFFICIAL
Explore all skills by this author →
WebsiteGitHub

kimchi:simplicity-enforcement

Enforce simplicity, YAGNI, and minimal abstraction in software design and implementation decisions.

8|Updated Jan 31, 2026
Search Tags:#code quality#software design#complexity#abstraction#yagni#simplicity
One-click install
npx skills add https://github.com/Tromml/kimchi --skill kimchi-simplicity-enforcement
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: kimchi:simplicity-enforcement
Source: https://github.com/Tromml/kimchi/tree/main/plugins/kimchi/skills/simplicity-enforcement
Command: npx skills add https://github.com/Tromml/kimchi --skill kimchi-simplicity-enforcement

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill combats unnecessary complexity in software design and implementation by enforcing principles like YAGNI (You Aren't Gonna Need It), preferring duplication over premature abstraction, and hardcoding values when configuration is not immediately required.

Core Features & Use Cases

  • Complexity Reduction: Guides developers to write simpler, more maintainable code.
  • Abstraction Guidance: Prevents over-engineering by advocating for duplication until a clear pattern emerges.
  • Use Case: When designing a new feature, consult this Skill to ensure you are not adding flexibility or abstractions that are not immediately needed, leading to a cleaner, more focused implementation.

Quick Start

Use the kimchi:simplicity-enforcement skill to review design decisions for the new user profile page.

Frequently Asked Questions about kimchi:simplicity-enforcement

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

FAQPage Schema
How do I enforce YAGNI principles to reduce software complexity?▼

Preventing over-engineering involves preferring duplication over premature abstraction and hardcoding values instead of building configuration systems until a clear, immediate need emerges.

When should I prefer code duplication over premature abstraction?▼

Preventing over-engineering involves preferring code duplication over premature abstraction and hardcoding values instead of building configuration systems until a clear, immediate need emerges.

How do I prevent over-engineering in software design?▼

To prevent over-engineering in software design, enforce minimal abstraction by hardcoding values instead of creating premature configurations and avoiding speculative flexibility during feature implementation.

What is the best way to review architectural decisions for unnecessary complexity?▼

The best way to review architectural decisions for unnecessary complexity is to evaluate them against YAGNI principles, ensuring no extra flexibility or abstractions are added before they are immediately required.

Does hardcoding values help reduce code complexity?▼

Yes, hardcoding values helps reduce code complexity by eliminating premature configuration systems, keeping the implementation focused only on what is immediately needed rather than speculative future requirements.

Related Skills

Explore More Software Engineering Skills→
TrecekTrecek
1

plan-arc

Propose a target architecture with components, boundaries, and diagrams.

Community
Advanced
HughYauHughYau
2.4k

writing-plans

Generates step-by-step implementation plans for multi-step software development tasks.

Community
Intermediate
HaaaiawdHaaaiawd
142

complexity-guard

Audits architectural and system design documents for anti-patterns and complexity scoring.

Community
Advanced
johnnystefanjohnnystefan

fundamentals/oop-design-principles

Refactor TypeScript class hierarchies into interface-driven composition and delegation.

Community
Intermediate