clean-code

Enforces clean-code standards for readable, maintainable software changes.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents messy, overcomplicated code by enforcing pragmatic standards that keep changes safe, readable, and easy to maintain.

Core Features & Use Cases

  • Concise, pragmatic conventions: Enforces SRP, DRY, KISS, YAGNI, and the Boy Scout rule to avoid unnecessary complexity.
  • Consistent naming and function design: Requires intention-revealing names, verb+ noun function naming, question-form booleans, and small/one-thing functions.
  • Change-safety discipline: Mandates thinking about dependencies before editing, and updating all dependents in the same task to avoid broken imports.
  • AI coding behavior rules: Directs how to respond during coding tasks—write the code to solve the request, fix bugs immediately, and ask when requirements are unclear.

Quick Start

Instruct the AI to “follow the clean-code skill rules” and then ask it to implement your specific feature or fix while keeping functions small, names intention-revealing, and dependent files updated together.

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 during AI-assisted feature implementation?

To enforce clean code standards, instruct the AI to follow pragmatic conventions like SRP, DRY, and KISS. This ensures generated feature implementations remain readable, maintainable, and free of unnecessary complexity during day-to-day coding tasks.

What naming conventions should I use for writing maintainable code?

Maintainable code requires intention-revealing names, verb+ noun function naming, and question-form booleans. These pragmatic naming conventions clarify purpose, improve readability, and keep software changes easy to understand during future refactoring.

How do I prevent broken imports when refactoring existing code?

To prevent broken imports during refactoring, apply dependency-aware editing practices. Mandate thinking about dependencies before modifying files, and update all dependent components in the same task to ensure change-safety across the codebase.

Does the Boy Scout rule help with software maintainability?

The Boy Scout rule improves software maintainability by enforcing pragmatic standards that keep code clean during bug fixes. It directs fixing bugs immediately and leaving the codebase clearer than found, preventing overcomplicated changes over time.

When do I need pragmatic standards for code review?

Pragmatic standards are needed for code review when evaluating readability and dependency safety. Applying SRP, DRY, KISS, and YAGNI conventions ensures changes remain small, low-branch functions are used, and unnecessary complexity is avoided.

What are the limitations of using clean code conventions for small functions?

Clean code conventions require small, one-thing functions with low branching, which may limit rapid prototyping. However, these constraints enforce intention-revealing naming and change-safety discipline, ensuring long-term maintainability over quick, messy implementations.