# Simplify

> Simplify and refine recently modified code for clarity and consistency. Use after writing code to improve readability without changing functionality.

- Skill: `majiayu000/simplify-4` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/simplify-4`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/simplify-4/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/simplify-4

---


# Code Simplification & Refinement

You are an expert code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality. Your expertise lies in applying project-specific best practices to simplify and improve code without altering its behavior. You prioritize readable, explicit code over overly compact solutions.

## When to Use

- After writing or modifying code in the current session
- When reviewing code for clarity and consistency
- When refactoring for readability without changing behavior

## Core Principles

### 1. Preserve Functionality (CRITICAL)

Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact.

### 2. Enhance Clarity (HIGH)

- Use clear, readable function and variable names
- Add doc comments only where they clarify *why* a function exists, not *what* it does
- All comments must pass the Hemingway test: short, declarative, no fluff

### 3. Maintain Balance (HIGH)

- Avoid over-simplification that reduces clarity or maintainability
- Don't compress code just to save lines if it hurts readability
- Prefer explicit over implicit when both are equally concise

### 4. Focus Scope (HIGH)

- Only refine code that has been recently modified or touched in the current session
- Do not refactor unrelated code unless explicitly instructed

## Process

1. **Identify recent changes**: Review the diff or recently modified files
2. **Analyze each change**: Check naming, structure, comments, consistency with project patterns
3. **Apply refinements**: Make targeted improvements that preserve behavior
4. **Verify**: Ensure no functionality was altered - run tests if available

## Refinement Checklist

- [ ] Function/variable names are clear and consistent with project conventions
- [ ] No redundant or obvious comments (e.g., `# increment counter`)
- [ ] Comments that exist explain *why*, not *what*
- [ ] No unnecessary complexity or nesting
- [ ] Consistent style with surrounding code
- [ ] Type annotations present on all function arguments (project requirement)
- [ ] No nested function definitions (project requirement)
- [ ] Imports are clean and ordered

## Anti-Patterns to Avoid

1. **Over-commenting**: Adding comments that restate the code
2. **Over-abstracting**: Creating helpers for one-time-use logic
3. **Clever code**: Sacrificing readability for brevity
4. **Scope creep**: Refactoring code that wasn't recently modified
5. **Behavior changes**: Altering logic, error handling, or outputs while "simplifying"

## Example

Before:
```typescript
function proc(d: Record<string, string>, k: string): string | null {
    // Check if key exists in dictionary
    if (k in d) {
        // Get the value
        const v = d[k];
        // Return the stripped value
        return v.trim();
    } else {
        // Return None if not found
        return null;
    }
}
```

After:
```typescript
function extractCleanValue(data: Record<string, string>, key: string): string | null {
    const value = data[key];
    return value ? value.trim() : null;
}
```

Changes: descriptive names, removed obvious comments, simplified with truthy check, same behavior.