kiss

Analyze source code and architecture for accidental complexity across five dimensions.

12|1|Updated Feb 9, 2026

Search Tags:#architecture #code review #refactoring #maintainability #complexity #simplification

Ready to run

npx skills add https://github.com/florianbuetow/claude-code --skill kiss-florianbuetow

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: kiss
Source: https://github.com/florianbuetow/claude-code/tree/main/plugins/kiss/skills/kiss
Command: npx skills add https://github.com/florianbuetow/claude-code --skill kiss-florianbuetow

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps developers identify and eliminate accidental complexity in their code and architecture, making software easier to understand, maintain, and evolve.

Core Features & Use Cases

Dimension Analysis: Audits code across five dimensions: Complexity, Abstraction, Redundancy, Coupling, and Architecture.
Actionable Findings: Provides severity-rated findings with concrete simplification suggestions.
Use Case: A developer suspects their codebase is becoming too complex. They use the kiss all command to get a comprehensive audit, identifying specific areas for refactoring to improve maintainability.

Quick Start

Use the kiss skill to find simplification opportunities in the attached file 'my_module.py'.

Frequently Asked Questions about kiss

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

FAQPage Schema

How do I find accidental complexity in my source code for refactoring?▼

To find accidental complexity for refactoring, analyze source code across five dimensions: complexity, over-abstraction, redundancy, coupling, and architecture. This process yields severity-rated findings and actionable simplification suggestions to improve maintainability.

What is architectural overhead and how do I simplify it in my software architecture?▼

Architectural overhead is unnecessary structural complexity that hinders software maintenance and evolution. You can simplify it by auditing your system architecture to identify and eliminate accidental complexity, resulting in clearer structural boundaries and improved maintainability.

Can I audit code complexity and maintainability for different programming languages?▼

Yes, you can audit code complexity and maintainability across various programming languages. The analysis identifies simplification opportunities and generates concrete refactoring suggestions regardless of the specific programming language used.

What's the best way to reduce code coupling and redundancy in a complex codebase?▼

The best way to reduce code coupling and redundancy is to perform a comprehensive audit across five dimensions of accidental complexity. This analysis generates severity ratings and actionable refactoring suggestions specifically targeting redundancy and coupling issues.

How do I get a comprehensive code complexity audit for my entire module?▼

To get a comprehensive code complexity audit for your module, run a full analysis on the attached source files. The audit identifies accidental complexity across five dimensions and outputs severity-rated findings with actionable refactoring suggestions.