kiss

Analyze code implementations for over-engineering against project conventions.

2|Updated May 24, 2026
One-click install
npx skills add https://github.com/CivicActions/ai-runbook-jh --skill kiss-civicactions
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: kiss
Source: https://github.com/CivicActions/ai-runbook-jh/tree/main/skills/kiss
Command: npx skills add https://github.com/CivicActions/ai-runbook-jh --skill kiss-civicactions

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill identifies unnecessary complexity, premature abstractions, and over-engineered solutions in your codebase, ensuring your implementation remains maintainable and lean.

Core Features & Use Cases

  • Complexity Assessment: Evaluates whether a proposed solution is appropriately simple or significantly over-engineered.
  • Signal Detection: Identifies specific anti-patterns like single-use abstractions, redundant custom utilities, and premature generalizations.
  • Use Case: When you are unsure if a complex custom hook or service layer is necessary, use this Skill to receive a critique and a recommendation for a simpler, more direct implementation.

Quick Start

Use the kiss skill to review the provided code implementation for unnecessary complexity and suggest a simpler approach.

Frequently Asked Questions about kiss

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

FAQPage Schema
How do I identify over-engineering and unnecessary complexity in my codebase?

To identify over-engineering in your codebase, analyze code implementations against project-specific stack conventions and universal simplicity principles to detect premature abstractions and single-use abstractions.

What are common signals of premature abstractions in software architecture?

Common signals of premature abstractions in software architecture include single-use abstractions, redundant custom utilities, and premature generalizations that deviate from framework-native alternatives and standard library capabilities.

How do I review code for unnecessary complexity during peer reviews?

Review code for unnecessary complexity during peer reviews by evaluating the provided code snippet against the project contract to ensure the implementation remains maintainable, lean, and appropriately simple.

Do I need a project contract to assess code simplicity and maintainability?

Yes, you need a project contract and the code snippet to evaluate code simplicity and maintainability, as the assessment requires comparing implementations against project-specific stack conventions and framework-native alternatives.

When should I not use custom utilities for software architecture?

You should avoid custom utilities for software architecture when they act as redundant single-use abstractions, and instead use framework-native alternatives or standard library capabilities to keep solutions maintainable and efficient.

What is the best way to eliminate over-engineering in a custom service layer?

The best way to eliminate over-engineering in a custom service layer is to critique it against project conventions to receive a recommendation for a simpler, more direct implementation using standard library capabilities.