clean-code

Enforce pragmatic coding standards for concise, maintainable software development.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/TudeOrangBiasa/zenithgravity-kit --skill clean-code-tudeorangbiasa
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/TudeOrangBiasa/zenithgravity-kit/tree/main/.agent/skills/clean-code
Command: npx skills add https://github.com/TudeOrangBiasa/zenithgravity-kit --skill clean-code-tudeorangbiasa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill enforces pragmatic coding standards to prevent over-engineering, unnecessary complexity, and excessive commenting, ensuring code is direct and maintainable.

Core Features & Use Cases

  • Concise Implementation: Prioritizes working code over lengthy explanations.
  • Simplified Structure: Encourages Single Responsibility Principle (SRP) and shallow nesting with guard clauses.
  • Self-Documenting Code: Emphasizes intent-revealing names over comments.
  • YAGNI Principle: Avoids premature abstraction and over-engineering.
  • Ecosystem Awareness: Checks for and updates all affected files within the same task boundary.

Quick Start

Apply clean code principles to the current codebase.

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 improve maintainability in my codebase?

To enforce clean code standards, apply the Single Responsibility Principle, utilize guard clauses for shallow nesting, and prioritize self-documenting code with intent-revealing names over excessive comments. This prevents over-engineering and ensures concise, maintainable software development.

What is the YAGNI principle and when should I apply it during refactoring?

The YAGNI principle means avoiding premature abstraction and over-engineering. Apply it during refactoring to prioritize working code over lengthy explanations, ensuring your software remains direct, concise, and free from unnecessary complexity before it is actually needed.

How do I refactor deeply nested code into a simplified structure?

Refactor deeply nested code into a simplified structure by replacing conditional branches with guard clauses. This enforces shallow nesting and the Single Responsibility Principle, making your codebase more direct and maintainable while reducing cognitive load.

Does writing self-documenting code eliminate the need for comments entirely?

Self-documenting code emphasizes intent-revealing names to explain functionality, which drastically reduces unnecessary commenting. While it prioritizes concise implementation over lengthy explanations, it focuses on making the code direct and maintainable rather than strictly eliminating all comments.

How do I ensure all affected files are updated when applying coding standards?

Ensure all affected files are updated during refactoring by enforcing updates within the same task boundary. This ecosystem awareness prevents broken dependencies and maintains structural integrity across your entire codebase while applying clean code standards.