clean-code

Enforces pragmatic coding standards for AI agents producing maintainable code.

Updated Feb 26, 2026
One-click install
npx skills add https://github.com/TheGreatL/KanbanBoard --skill clean-code-thegreatl
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/TheGreatL/KanbanBoard/tree/main/.agents/skills/clean-code
Command: npx skills add https://github.com/TheGreatL/KanbanBoard --skill clean-code-thegreatl

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill enforces pragmatic coding standards to ensure code is concise, direct, and avoids over-engineering, leading to more maintainable and understandable software.

Core Features & Use Cases

  • Enforces SOLID principles: Promotes Single Responsibility, DRY, KISS, and YAGNI.
  • Improves Naming Conventions: Guides on clear and intent-revealing names for variables, functions, and constants.
  • Optimizes Function Design: Encourages small, focused functions with minimal arguments and no side effects.
  • Streamlines Code Structure: Advocates for guard clauses, flat nesting, and composition.
  • AI Coding Guidance: Provides specific instructions for AI agents on how to interact with users and code.
  • Pre-edit Checks: Mandates thinking about dependencies and impact before modifying files.
  • Post-task Verification: Requires self-checking for goal completion, code correctness, and error-free execution.
  • Script Execution: Defines mandatory script execution for validation and quality checks.

Quick Start

Apply the clean-code skill to refactor the provided user service implementation.

Frequently Asked Questions about clean-code

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

FAQPage Schema
How do I enforce clean code standards and prevent over-engineering when using AI agents?

To enforce clean code standards with AI agents, apply pragmatic coding rules emphasizing conciseness, directness, and avoiding over-engineering. This ensures generated code remains maintainable, follows SOLID principles, and avoids unnecessary complexity.

What are the best practices for refactoring code to improve naming conventions and function design?

Best practices for refactoring involve applying clear naming conventions and optimizing function design. This means creating small, focused functions with minimal arguments, no side effects, and intent-revealing names for variables and constants.

How do I apply SOLID, DRY, and KISS principles during code structure optimization?

Applying SOLID, DRY, and KISS principles involves streamlining code structure through guard clauses, flat nesting, and composition. This pragmatic approach keeps code concise, promotes single responsibility, and eliminates redundant logic.

Why should I perform pre-edit impact analysis before modifying existing code files?

Pre-edit impact analysis is necessary before modifying code files to evaluate dependencies and potential effects. This mandatory step prevents unintended side effects, ensures code correctness, and maintains structural integrity.

How do I verify code correctness and quality after completing a refactoring task?

To verify code correctness after a refactoring task, execute mandatory validation scripts and perform post-task self-checks. This confirms goal completion, ensures error-free execution, and validates quality standards.