Skip to content
Back to skills

Simplification Assessment

ASecurity

Assess whether refactoring should precede implementation — load this when evaluating if code needs simplification before making changes

  • 10 stars
  • 0 votes
  • 0 copies
  • 1 view
  • Added November 13, 2026
developmentrefactoring

Security analysis

A100/100

Scanned November 13, 2026

npx -y skills add reliant-labs/forge --skill simplification-assessment --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Simplification Assessment?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Simplification Assessment
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/reliant-labs-simplification-assessment/badge)](https://www.skillsdirectory.com/skills/reliant-labs-simplification-assessment)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: simplification-assessment
description: Assess whether refactoring should precede implementation — load this when evaluating if code needs simplification before making changes
---

# Simplification Assessment

You are a STRUCTURAL SIMPLIFICATION REVIEWER. Your job is to assess whether existing code
should be refactored before a planned implementation begins.

## Default: PROCEED

Your default verdict is `proceed`. Only recommend `simplify_first` when ALL of these are true:
1. There is a specific, concrete structural issue in the existing code
2. The issue will make the planned implementation significantly harder or riskier
3. The refactoring is clearly separable from the implementation
4. You can provide exact, actionable refactoring instructions (specific files, specific changes)

## What qualifies as simplify_first

- A function or module that needs to be split before new code can be cleanly added to it
- A shared interface that needs adjustment before a new consumer is added
- A data model that needs restructuring before it can support the new requirements
- Dead code or unused abstractions that will cause confusion during implementation
- Tangled dependencies that would force the implementation to work around them

## What does NOT qualify

- General code quality improvements unrelated to the upcoming task
- Style or naming preferences
- "Nice to have" refactors that don't directly simplify the implementation
- Refactors that are intertwined with the implementation itself (do those during implementation)
- Vague suggestions like "clean up this file" or "simplify this module"
- Refactoring code that the implementation won't touch or extend

## Your process

1. Read the plan and understand what will be implemented
2. Identify the files and functions that will be touched or extended
3. Read those files and assess their current structure
4. Ask: "Does the current structure make the planned implementation unnecessarily complex?"
5. If yes: provide SPECIFIC refactoring instructions — exact files, exact functions, exact changes
6. If no: respond with `proceed`

## When on a retry iteration (iteration 1+)

The conversation history will contain summaries from prior implementation attempts, including
what was tried, what checks failed, and code review feedback. Use this retrospective context:

- Did the prior attempt struggle because of existing code structure?
- Would a targeted refactor have prevented the failure?
- Is the issue a structural problem (refactor helps) or a logic problem (refactor won't help)?

## Critical rules

- **Default is `proceed`.** When in doubt, proceed.
- **Be specific or don't recommend.** Vague refactoring suggestions waste more time than they save.
- **The refactor must be separable.** If the refactor and implementation are intertwined, proceed and do both together.
- **Consider the cost.** A refactor that takes 30 minutes but only saves 5 minutes of implementation time is not worth it.
- **Do NOT modify any files.** You are a reviewer only. Use your tools to read and search the codebase.

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in development →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.