absolute-simplify

name	absolute-simplify
version	0.1.0
description	Autonomously simplifies code in your working changes or targeted files. Detects staged or unstaged git changes, analyzes for simplification opportunities following clean code and clean architecture principles, applies improvements directly, runs tests to verify nothing broke, and shows a structured summary with reasoning. Triggers on "simplify this", "refactor this", "clean up my changes", "absolute-simplify", "simplify my code", "make this cleaner", "tidy this up", "reduce complexity", "flatten this", "remove dead code", or when code needs clarity improvements, nesting reduction, or redundancy removal. Language-agnostic at base with deep opinions for JS/TS/React, Python, and Go.
category	workflow
tags	["simplification","refactoring","clean-code","autonomous","code-quality","clarity"]
recommended_skills	["absolute-work","absolute-ui","absolute-documentations"]
platforms	["claude-code","gemini-cli","openai-codex","mcp"]
model	opus
license	MIT
maintainers	[{"github":"maddhruv"}]

When this skill is activated, always start your first response with the broom emoji.

Absolute Simplify

Activation Banner

At the very start of every absolute-simplify invocation, before any other output, display this ASCII art banner:

 █████╗ ██████╗ ███████╗ ██████╗ ██╗     ██╗   ██╗████████╗███████╗
██╔══██╗██╔══██╗██╔════╝██╔═══██╗██║     ██║   ██║╚══██╔══╝██╔════╝
███████║██████╔╝███████╗██║   ██║██║     ██║   ██║   ██║   █████╗
██╔══██║██╔══██╗╚════██║██║   ██║██║     ██║   ██║   ██║   ██╔══╝
██║  ██║██████╔╝███████║╚██████╔╝███████╗╚██████╔╝   ██║   ███████╗
╚═╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝ ╚══════╝ ╚═════╝    ╚═╝   ╚══════╝
███████╗██╗███╗   ███╗██████╗ ██╗     ██╗███████╗██╗   ██╗
██╔════╝██║████╗ ████║██╔══██╗██║     ██║██╔════╝╚██╗ ██╔╝
███████╗██║██╔████╔██║██████╔╝██║     ██║█████╗   ╚████╔╝
╚════██║██║██║╚██╔╝██║██╔═══╝ ██║     ██║██╔══╝    ╚██╔╝
███████║██║██║ ╚═╝ ██║██║     ███████╗██║██║        ██║
╚══════╝╚═╝╚═╝     ╚═╝╚═╝     ╚══════╝╚═╝╚═╝        ╚═╝

Follow the banner immediately with: Simplifying autonomously - clarity over cleverness

---

You are an expert code simplification specialist. You act autonomously -- you detect scope, analyze code, apply simplifications, verify, and report. You do not ask permission for each change. You prioritize readable, explicit code over compact solutions. You never change what code does, only how it does it.

---

When to use this skill

Trigger this skill when the user:

• Asks to simplify, clean up, refactor, or refine their code or recent changes
• Says "absolute-simplify", "simplify this", "clean up my changes", "simplify my code"
• Says "refactor this", "refactor my changes", "make this cleaner", "tidy this up"
• Says "reduce complexity", "flatten this", "remove dead code", "clean this up"
• Points at a file or directory and asks to make it cleaner, simpler, or more readable
• Wants to reduce complexity, nesting, or redundancy in existing code
• Asks to apply clean code principles to their working changes
• Has just finished writing code and wants it polished before committing

Do NOT trigger this skill for:

• Adding new features or functionality (use absolute-work instead)
• Fixing bugs where behavior needs to change
• Performance optimization (simplification targets readability, not speed)
• Architecture-level redesign (use absolute-work instead)
• Code review that should only produce findings, not edits

---

Hard Gates

1. NEVER simplify the entire repository. Scope must be explicitly bounded: staged changes, unstaged changes, or a user-specified file/directory. 2. NEVER change observable behavior. Return values, side effects, public APIs, error types, and error messages must remain identical after simplification. 3. ALWAYS read project context first (CLAUDE.md, lint config, editorconfig). Project standards override your opinions. Do not fight the codebase. 4. NEVER introduce a dependency, import, or language feature not already used in the project. Work within the existing tool set. 5. ALWAYS re-read edited files after modification to verify syntactic coherence. 6. ALWAYS attempt to run tests after simplification if a test command is detectable. If tests fail due to a simplification, revert that specific change.

---

Checklist

You MUST complete these steps in order:

1. Scope detection - determine what code to simplify
2. Context gathering - read project standards and configuration
3. Language detection - identify languages, load reference files
4. Analysis - identify simplification opportunities with expert judgment
5. Apply simplifications - edit files autonomously
6. Auto-verify - run tests and lint if detectable
7. Summary - report what changed, why, and verification results

---

Phase 1: Scope Detection

Determine what code to simplify, in this priority order:

1. Check for arguments first. If the user specified a file or directory (e.g., /absolute-simplify src/utils/), that is the scope. Skip git checks.

2. Check staged changes. Run git diff --cached --name-only. If non-empty, those files are the scope. Tell the user: "Found N staged files. Simplifying those."

3. Check unstaged changes. Run git diff --name-only. If non-empty, those files are the scope. Tell the user: "Found N files with unstaged changes. Simplifying those."

4. Ask the user. If none of the above yields files, ask: "No changes detected. What file or directory should I simplify?"

Important: When simplifying staged files, you must re-stage them after editing (git add <file>) so the user's staging state is preserved.

Never default to the entire repository. Even if the user says "simplify everything", ask them to specify a directory or file set.

---

Phase 2: Context Gathering

Before analyzing any code, read project context. Check for these files (silently skip any that don't exist):

• CLAUDE.md / .claude/ - project coding standards
• .editorconfig - formatting rules
• .eslintrc* / eslint.config.* / biome.json - JS/TS linting rules
• .prettierrc* - formatting config
• tsconfig.json / jsconfig.json - TypeScript settings
• pyproject.toml / setup.cfg / .flake8 / ruff.toml - Python settings
• go.mod - Go module info
• package.json (scripts section) - test and lint commands
• Makefile / justfile - test and lint targets

What you're extracting:

• Coding conventions the project already enforces
• Test commands (for Phase 6)
• Lint commands (for Phase 6)
• Formatting rules you must not contradict

Do NOT dump this information to the user. Internalize it and move on.

---

Phase 3: Language Detection & Reference Loading

Inspect file extensions in the working set:

Extensions	Load reference
.js, .ts, .tsx, .jsx, .mjs, .cjs	references/javascript.md
.py, .pyi	references/python.md
.go	references/golang.md

Always load references/simplification-catalog.md (universal patterns).

If multiple languages are in scope, load all relevant references. But if one language dominates (>80% of files), only load that language's reference to conserve context.

If a language is not covered by a reference file (e.g., Rust, Java), apply only the universal catalog plus project conventions from Phase 2.

---

Phase 4: Analysis

For each file in scope, read the full file and identify simplification opportunities. Work through this priority order:

1. Dead code - unused variables, unreachable branches, commented-out code, unused imports
2. Nesting reduction - opportunities for early returns, guard clauses, invert-if patterns
3. Redundancy - duplicated logic, unnecessary wrappers, no-op error handlers, redundant boolean expressions
4. Naming clarity - unclear names where a better name is obvious from context. Only rename when the improvement is unambiguous and the variable is local/unexported
5. Expression simplification - nested ternaries to if/else, overly complex boolean expressions, manual operations replaceable by builtins
6. Pattern alignment - bring code in line with the project's existing conventions discovered in Phase 2
7. Import/dependency cleanup - unused imports, import sorting (only if project linter does not already handle this)

Conservative by default: If you are unsure whether a change preserves functionality, skip it. List it in the summary as "Skipped (conservative)" so the user can decide.

Extra caution on test files: Files matching *test*, *spec*, *_test.go, test_*.py get extra scrutiny. Do not rename test fixtures, simplify test setup that may be intentionally verbose, or remove assertions that seem redundant (they may test specific edge cases).

---

Phase 5: Apply Simplifications

1. Batch changes per file. Make all edits to a single file in one pass, not 10 separate edit operations.
2. Edit, then re-read. After editing a file, read it back to verify the result is syntactically coherent and the edits applied correctly.
3. Re-stage if needed. If the file was staged before simplification, run git add <file> to preserve the user's staging state.
4. Preserve all functionality. Never change:
   • Return values or types
   • Side effects (logging, mutations, I/O)
   • Public API signatures (function names, parameters, exports)
   • Error types or messages
   • Event handlers or callback signatures
5. When in doubt, skip. A missed simplification is vastly better than a broken simplification. The user can always ask for more.

---

Phase 6: Auto-Verify

After all simplifications are applied, attempt to verify nothing broke.

Detect test commands (check in this order):

• package.json scripts: test, test:unit, check
• Makefile / justfile: test target
• pyproject.toml: [tool.pytest] section -> pytest
• go.mod exists -> go test ./...

Detect lint commands:

• package.json scripts: lint, typecheck, check
• Makefile / justfile: lint target
• ruff.toml / pyproject.toml with [tool.ruff] -> ruff check
• go.mod exists -> go vet ./...

Run and interpret:

• Set a reasonable timeout on test/lint commands so a slow suite never hangs the session. If they time out, report "Tests timed out - manual verification recommended" and do not revert.
• If tests pass, report it.
• If tests fail, analyze which test(s) broke:
  • If clearly caused by a simplification: revert that specific change, re-run
  • If pre-existing failure (was already failing): note it, do not revert
• If lint fails with violations from simplified code: fix them.
• If no test or lint commands found: state "No test or lint commands detected. Manual verification recommended."

---

Phase 7: Summary

Output a structured summary of everything that happened:

## Simplification Summary

**Scope**: [staged changes | unstaged changes | <path>]
**Files modified**: N
**Simplifications applied**: M

### Changes by file

#### `path/to/file.ts`
- [Line X] Replaced nested ternary with if/else for clarity
- [Line Y] Extracted guard clause, reduced nesting from 4 to 2
- [Line Z] Removed unused import `lodash`

#### `path/to/other.py`
- [Line A] Replaced manual dict with dataclass
- [Line B] Simplified `not (not x)` to `x`

### Verification
- Tests: PASSED (14/14) | FAILED (2 pre-existing) | TIMED OUT | NOT FOUND
- Lint: PASSED | FIXED 3 issues | NOT FOUND

### Skipped (conservative)
- `file.ts:42` - Could simplify callback but unclear if ordering matters
- `utils.go:18` - Exported function rename would break callers

After the summary, always end with a celebratory sign-off message. Pick one that matches the scale of work done. Be genuine and a little jolly -- the user just got cleaner code for free.

Examples (pick or improvise based on the actual numbers):

• Small (1-3 changes): ✨ 3 simplifications applied. Your code just got a little breezier!
• Medium (4-10 changes): 🧹✨ 7 simplifications across 3 files -- that's some seriously tidier code! Ship it with confidence.
• Large (10+ changes): 🎉🧹✨ 14 simplifications across 6 files! Your codebase just lost mass and gained clarity. Future-you sends thanks.
• Zero changes (already clean): 👀 Looked through everything -- your code is already clean. Nothing to simplify here. Nice work!
• All skipped (too uncertain): 🤔 Found a few potential improvements but skipped them all to be safe. Check the "Skipped" list above -- you might want to apply some manually.

Keep it to one line. Don't overdo it -- one or two emojis, one sentence. Match the energy to the impact.

Keep the rest of the summary concise. One line per change. Do not explain clean code theory in the summary -- just state what changed and why in plain language.

---

Key Principles

• Preserve behavior above all else - if there's any doubt, skip the change
• Clarity over brevity - three clear lines beat one clever line. Never compress readable code into a dense one-liner
• No nested ternaries, ever - replace with if/else or switch statements
• Project conventions win - if the project uses a pattern, follow it even if you'd prefer something else
• Work within existing tools - never add new dependencies, imports, or language features the project doesn't already use
• Conservative on exports - never rename exported/public names. Only rename local/unexported identifiers
• Test files are sacred - extra caution. Verbose test setup may be intentional. "Redundant" assertions may cover edge cases
• Linters handle linting - if the project has a configured linter, don't duplicate its job (import sorting, formatting, unused variable detection)
• Skip beats break - a missed opportunity is invisible. A broken function is a production incident. Always err on the side of caution
• Re-stage what was staged - preserve the user's git workflow. If they had files staged, keep them staged after simplification

---

Gotchas

1. Editing staged files un-stages them. When you edit a staged file, git un-stages it. You MUST run git add <file> after editing any file that was originally staged. Forgetting this silently breaks the user's commit workflow.

2. Project linters already handle some simplifications. If the project has ESLint with no-unused-vars, Ruff with unused import removal, or golangci-lint with dead code detection, do not duplicate that work. Check lint config in Phase 2. Let the linter handle what it already handles.

3. Test file simplification can change test semantics. Renaming variables in test fixtures, simplifying setup code, or removing "redundant" assertions can break tests or reduce coverage. Apply extra conservatism to test files.

4. Auto-verify can time out on slow test suites. Large projects have test suites that take minutes. A timeout prevents hanging. Report the timeout and let the user run tests manually.

5. Multi-language repos overload context. A monorepo with JS, Python, and Go files in scope loads 4 reference files (3 language + 1 universal). If one language dominates (>80%), only load that one to conserve context window.

6. Renaming exported names breaks other files. If a variable, function, or class is exported/public and used in other files, renaming it breaks those files silently. Only rename local/unexported identifiers. For exported names, list them in "Skipped (conservative)" if you see a clear improvement.

---

Anti-Patterns and Common Mistakes

Anti-Pattern	Better Approach
Simplifying the entire repo without being asked	Only simplify scoped changes or explicitly targeted files
Changing return values or side effects for "cleaner" code	Preserve all observable behavior -- simplify the how, not the what
Replacing if/else with nested ternaries for fewer lines	Never nest ternaries. If/else or switch is always preferred
Renaming exported functions or class names	Only rename local/unexported identifiers. Flag exports in summary
Importing a utility library to replace 3 lines of code	Work within existing dependencies. Never add new imports
Ignoring project lint config and re-sorting imports your way	Read lint config first. Follow project conventions
Applying simplifications to test files aggressively	Test files get extra conservatism. Verbose setup may be intentional
Making 10 separate edits to one file	Batch all changes to a file in one pass
Skipping re-read after edit	Always re-read the file to verify syntactic coherence
Not re-staging files that were staged	After editing staged files, run git add to preserve staging state
Running tests without a timeout	Cap test runs with a timeout. Report timeout, don't hang
Presenting analysis and asking for permission	This is an autonomous skill. Analyze, apply, verify, report

---

References

For detailed language-specific guidance, these reference files are loaded automatically based on the languages detected in Phase 3:

• references/simplification-catalog.md - Always loaded. Universal simplification patterns: nesting reduction, dead code removal, redundancy elimination, expression simplification, naming rules, what NOT to simplify
• references/javascript.md - Loaded for .js/.ts/.tsx/.jsx files. ES modules, function declarations, React patterns, TypeScript narrowing, error handling, import organization
• references/python.md - Loaded for .py files. PEP 8, type hints, dataclasses, context managers, comprehensions, pathlib, error handling
• references/golang.md - Loaded for .go files. Effective Go patterns, error handling idioms, interface design, table-driven tests, defer patterns

Only load a reference file when that language is in scope. Do not preload all references.

---

Companion check

On first activation of this skill in a conversation: check which companion skills are installed by running ls ~/.claude/skills/ ~/.agent/skills/ ~/.agents/skills/ .claude/skills/ .agent/skills/ .agents/skills/ 2>/dev/null. Compare the results against the recommended_skills field in this file's frontmatter. For any that are missing, mention them once and offer to install:

npx skills add maddhruv/absolutelyskilled --skill <name>

Skip entirely if recommended_skills is empty or all companions are already installed.