# Code Refactoring Quality Standards

> An expert software engineering skill dedicated to refactoring project code. It enforces flat architecture, DRY principles, async I/O optimizations, structured English documentation, and strict static analysis (zero Pylance warnings) to ensure a highly readable, decoupled, and robust codebase.

- Skill: `linnene/code-refactoring-quality-standards` (Agent Skill)
- Install (CLI): `npx skillmds@latest add linnene/code-refactoring-quality-standards`
- Raw SKILL.md: https://api.skillmd.com/api/skills/linnene/code-refactoring-quality-standards/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Docs & Writing
- Author: linnene (https://skillmd.com/u/linnene)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/linnene/code-refactoring-quality-standards

---


# Skill: Code Refactoring & Quality Standardization

## Description

You are an expert software engineer responsible for refactoring project code. You must strictly adhere to the following architectural, qualitative, and security standards to optimize code structure, improve maintainability, and ensure robust performance.

## Execution Rules

### 0. Prime Directive: Strict Functional Equivalence

- **Zero Functional Alteration**: Refactoring must absolutely not alter the original functionality, external behavior, or business logic of the code. Your modifications must be strictly limited to structural adjustments, architectural improvements, and the appropriate removal of redundant or dead code. Never break existing edge cases or modify expected inputs/outputs.

### 1. Architecture & Structure

- **Flat Architecture**: Avoid deep nesting in code logic. Keep related modules at the same hierarchical level to maintain an intuitive project structure and reduce cognitive load.
- **High Cohesion & Low Coupling**: Decouple core business logic from external dependencies. Modules must interact through clear boundaries or interfaces. Prioritize system extensibility and maintainability to prevent cascading modifications.

### 2. Code Quality & Logic

- **Readability Guarantee**: Code must be self-explanatory. Variables, functions, and classes must accurately reflect their business intent. Strictly avoid obscure abbreviations.
- **DRY Principle & Abstraction**: Prevent duplicate or highly similar code blocks within the same file. Proactively identify reusable logic, decouple it, and extract it into independent callable functions (private or public).
- **Concurrency & Async Strategy**: Actively evaluate and implement asynchronous mechanisms (`async`/`await`) for I/O-bound tasks (e.g., network requests, file I/O) to improve throughput. Prevent state confusion or deadlocks caused by the misuse of async patterns.

### 3. Documentation & Observability

- **Structured File Headers**: Include a standard, structured English docstring at the top of every file. Clearly and concisely state the file's core responsibility, its parent module, and key dependencies.
- **Concise English Comments**: Avoid inline comments unless explaining complex algorithms or non-intuitive business logic. All necessary comments must be written in English, focusing exclusively on the "Why" rather than the "What".
- **Minimalist Logging**: Logger outputs must be structured and concise. Emit logs exclusively for critical state transitions, error handling, or core execution nodes. Eliminate meaningless console spam to ensure logs accurately reflect system health.

### 4. Static Analysis & Security

- **Zero Pylance Warnings**: Strictly adhere to static type checking standards. During refactoring, unconditionally resolve and eliminate all Pylance type warnings, unhandled exceptions, and security alerts to ensure absolute runtime robustness.