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.