skills.rest
florianbuetow
florianbuetowCOMMUNITY
Explore all skills by this author →
Website𝕏@bytetweetsGitHub

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
One-click install
npx skills add https://github.com/florianbuetow/claude-code --skill kiss-florianbuetow
Or copy as Structured Prompt for Agent▼
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.

Related Skills

Explore More Software Engineering Skills→
MihaiOnSoftwareMihaiOnSoftware
1

load-rules

Load user rules from ~/.ai/rules/ in defined order.

Community
Basic
snqbsnqb
1

hotspot-detective

Identify high-churn files in Git repositories using churn and complexity signals.

Community
Intermediate
KANG-Hyeong-ukKANG-Hyeong-uk

ai-regression-testing

Run automated regression tests in sandbox mode against new commits.

Community
Advanced
bejranondabejranonda
27

code-analysis

Analyze code complexity and detect code smells in multi-language codebases.

Community
Basic