Simplify

Review all changed code for opportunities to reduce complexity, eliminate duplication, and improve quality.

Scope: the arguments provided when this skill is invoked

Instructions

Step 1: Get the Diff Scope

Compare against the fork point with the remote base (three dots), not a local main: two dots against a stale or moved base also lists the base's own newer commits as if this branch made them.

BASE=$(git symbolic-ref --short refs/remotes/origin/HEAD 2>/dev/null | sed 's#^origin/##')
BASE=${BASE:-main}
git fetch --quiet origin "$BASE"
git diff "origin/$BASE"...HEAD --stat
git diff --cached --stat
git diff --stat

Step 2: Review Each Changed File

For each changed file, read the entire file and check:

• Code reuse: does new code duplicate existing utilities or helpers? Search the codebase for similar patterns.
• Over-engineering: unnecessary abstractions, premature generalization, excessive configurability for one-time operations.
• Dead code: unused imports, unreachable branches, commented-out code.
• Redundancy: repeated logic that could be a shared helper (only if 3+ occurrences).
• Complexity: can any function be simplified without losing clarity?
• Efficiency: redundant computations, repeated file reads, duplicate API calls.
• Naming: unclear variable or function names that could be more descriptive.

Step 3: Apply Simplifications

Apply each simplification directly. After changes, verify tests still pass, skipping only when an identical check already passed earlier in this autonomous pipeline cycle for this exact worktree state (a no-op outside the autonomous pipeline: sova checks should-skip only ever reports a skip there). Here that can only happen when no simplification was applied, since any edit changes the state the skip is keyed to:

if sova checks should-skip "make check"; then
  echo "Full check already passed for this worktree state earlier in the pipeline cycle; skipping re-run."
else
  make check && { sova checks record "make check" --passed || true; }
fi

If a simplification is risky, skip it. Only apply safe, clear improvements.

Step 4: Summary

If no simplifications are needed, state that explicitly.

If changes were made, summarize:

## Simplification Summary

**Changes applied**: N
- [brief description of each change]

**Tests**: passing

Rules

• Do NOT reformat code that was not changed in this branch.
• Do NOT add docstrings, comments, or type annotations to unchanged code.
• Do NOT create abstractions for fewer than 3 occurrences.
• Do NOT add error handling for scenarios that cannot happen.
• Three similar lines of code is better than a premature abstraction.
• NEVER use emojis in any output.