Agent Skills: Code Simplifier Skill

Code Simplifier Skill

Simplify and refine code for clarity, consistency, and maintainability.

Summary

Goal: Analyze and simplify code by applying KISS, DRY, YAGNI principles while preserving all functionality.

| Step | Action | Key Notes | |------|--------|-----------| | 1 | Identify targets | Recent changes via git diff or specified files; skip generated/vendor | | 2 | Analyze complexity | Nesting >3, methods >20 lines, duplicated code, unclear naming | | 3 | Apply simplifications | One refactoring type at a time; follow platform patterns | | 4 | Verify | Run related tests, confirm no behavior changes |

Key Principles:

• Preserve ALL existing functionality -- simplify, never change behavior
• Backend: extract static expressions, use fluent helpers (.With(), .PipeIf())
• Frontend: use PlatformVmStore, untilDestroyed(), BEM naming

Usage

/code-simplifier                    # Simplify recently modified files
/code-simplifier path/to/file.ts    # Simplify specific file
/code-simplifier --scope=function   # Focus on function-level simplification

⚠️ Anti-Hallucination Reminder

Before modifying ANY code: Verify assumptions with actual code evidence. Search for usages, read implementations, trace dependencies. If confidence < 90% on any change, investigate first or ask user. See .claude/skills/shared/anti-hallucination-protocol.md for full protocol.

What It Does

1. Analyzes code for unnecessary complexity
2. Identifies opportunities to simplify without changing behavior
3. Applies KISS, DRY, and YAGNI principles
4. Preserves all existing functionality

Simplification Targets

• Redundant code paths
• Over-engineered abstractions
• Unnecessary comments (self-documenting code preferred)
• Complex conditionals that can be flattened
• Verbose patterns that have simpler alternatives

Execution

Use the code-simplifier:code-simplifier subagent:

Task(subagent_type="code-simplifier:code-simplifier", prompt="Review and simplify [target files]")

Complexity Thresholds

| Metric | Threshold | Action | | --------------- | -------------- | -------------------------------- | | Nesting depth | > 3 levels | Flatten with guard clauses | | Method length | > 20 lines | Extract focused methods | | Duplicated code | 2+ occurrences | Apply DRY, use platform patterns | | Naming clarity | Unclear intent | Make self-documenting |

EasyPlatform Patterns to Apply

Backend (C#)

• Extract to Entity.XxxExpr() static expressions
• Use fluent helpers: .With(), .Then(), .PipeIf()
• Move mapping to DTO MapToObject() / MapToEntity()
• Use PlatformValidationResult fluent API

Frontend (TypeScript)

• Use PlatformVmStore for state management
• Apply untilDestroyed() to all subscriptions
• Ensure BEM class naming on all elements
• Use observerLoadingErrorState() for loading states

Simplification Actions

| Action | Description | | --------------------- | ---------------------------------------------- | | Reduce nesting | Flatten deep if/else chains with guard clauses | | Extract methods | Break long methods into focused units | | Simplify conditionals | Use early returns, named booleans | | Remove duplication | Apply DRY, use platform patterns | | Improve naming | Make code self-documenting |

Workflow

1. Identify targets

   • If no arguments: git diff --name-only HEAD~1 for recent changes
   • If arguments provided: use specified files/patterns
   • Skip: generated code, migrations, vendor files

2. Analyze each file

   • Identify complexity hotspots (nesting > 3, methods > 20 lines)
   • Find duplicated code patterns
   • Check naming clarity

3. Apply simplifications

   • One refactoring type at a time
   • Preserve all functionality
   • Follow platform patterns

4. Verify

   • Run related tests if available
   • Confirm no behavior changes

Examples

Generic Example:

Before:

function getData() {
  const result = fetchData();
  if (result !== null && result !== undefined) {
    return result;
  } else {
    return null;
  }
}

After:

function getData() {
  return fetchData() ?? null;
}

Concrete Example Output:

User: /code-simplifier src/Domain/Entities/Employee.cs

Claude:
1. Analyzed Employee.cs (145 lines)
2. Found: 2 nested conditionals, 1 duplicated expression
3. Applied:
   - Extracted IsActiveInCompanyExpr() static expression
   - Replaced nested if with guard clause in Validate()
   - Renamed `x` to `employee` in lambda
4. Tests: All passing
5. Complexity reduced: 145 -> 128 lines

IMPORTANT Task Planning Notes

• Always plan and break many small todo tasks
• Always add a final review todo task to review the works done at the end to find any fix or enhancement needed