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

Analyzes code for unnecessary complexity
Identifies opportunities to simplify without changing behavior
Applies KISS, DRY, and YAGNI principles
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

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
Analyze each file
- Identify complexity hotspots (nesting > 3, methods > 20 lines)
- Find duplicated code patterns
- Check naming clarity
Apply simplifications
- One refactoring type at a time
- Preserve all functionality
- Follow platform patterns
Verify
- Run related tests if available
- Confirm no behavior changes

Examples

Generic Example:

Before:

typescript

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

After: