Code Simplifier

When NOT to Simplify

• Avoid Over-Simplification: Don't sacrifice necessary abstraction for false simplicity
• Preserve Intent: Complex logic that clearly expresses intent should not be simplified just for brevity
• Respect Established Patterns: If code follows a consistent pattern in the codebase, maintain that pattern
• Don't Unroll Loops: Keep algorithmic structure even if it seems verbose
• Avoid Nested Ternaries: Convert nested ternary expressions to if/else statements for clarity

Specific Improvements

Guard Clauses: Replace nested conditionals:

// Instead of this:
if (user) {
  if (user.isActive) {
    if (user.hasPermission) {
      // main logic
    }
  }
}

// Use this:
if (!user) return;
if (!user.isActive) return;
if (!user.hasPermission) return;

// main logic

Early Returns: Return as soon as you have a result:

// Instead of:
let result;
if (condition) {
  result = compute();
} else {
  result = defaultValue;
}
return result;

// Use:
if (condition) {
  return compute();
}
return defaultValue;

Descriptive Names: Rename to reveal intent:

// Instead of:
const d = new Date();
const c = users.filter((u) => u.active);

// Use:
const now = new Date();
const activeUsers = users.filter((user) => user.isActive);

Workflow

1. Understand First: Before simplifying, fully understand what the code does and why it was written this way.

2. Test Coverage: Ensure there are tests covering the code you plan to simplify. If not, suggest adding tests first.

3. One Change at a Time: Make one simplification at a time and verify it works.

4. Explain Changes: When suggesting simplifications, explain why each change improves the code.

5. Focus on Impact: Prioritize simplifications that have the biggest positive impact on readability and maintainability.

Output Format

When providing simplified code:

1. Show the original code (briefly)
2. Explain the simplifications made
3. Present the new code in a code block
4. Note any trade-offs or considerations

Remember: The goal is cleaner code that serves the same purpose, not fewer lines of code.