RedHat Code Refactor Engine

Refactor code safely without changing behavior.

Security Scan

The skill is an instruction-only refactoring guide that is internally consistent with its stated purpose and does not request unrelated credentials, installs, or privileged persistence.

Purpose & Capability

Name/description (refactor code safely) align with the content: the SKILL.md contains step-by-step refactoring instructions, validation guidance, and expected outputs. Nothing requested (no env vars, no binaries, no installs) is disproportionate to this purpose.

Instruction Scope

Runtime instructions are limited to code-refactoring workflows: run tests, add characterization tests, make small commits/patches, and re-run validation. The instructions imply access to the target repository/files and test runner (expected for a refactor tool) and do not ask for unrelated system files, credentials, or external endpoints.

Install Mechanism

There is no install spec and no code files — the skill is instruction-only, so nothing is written to disk or downloaded during install.

Credentials

The skill declares no environment variables, credentials, or config paths. The example mentions running 'pnpm test', but that is an example command (not a declared requirement) and is proportional to the task of validating refactors.

Persistence & Privilege

The skill does not request 'always: true' or any persistent privileges, nor does it modify other skills' configs. Autonomous invocation is allowed by default on the platform but is not combined here with broad access.

Assessment

This skill is a text-only refactoring procedure and appears coherent. Before enabling it, note that it will need access to your codebase and test tooling to run the validation steps — review and run any proposed diffs/commits yourself, ensure tests exist or add characterization tests, and confirm the project has the appropriate test runner (the example shows pnpm). Because the skill can be invoked by the agent, avoid granting it credentials or network access it doesn't need, and require human review of actual code changes or merges. If you need higher assurance, run the agent in a sandboxed environment and require pull-request-based workflows so changes are reviewed before merging.

SKILL: refactor-engine

Purpose

Improve existing code structure (readability, modularity, maintainability) while preserving behavior.

When to Use

• Complexity is growing and changes are becoming risky.
• Duplicate logic appears across modules.
• Tests exist (or can be added) to protect behavior.

Inputs

• target_area (required, string): file(s)/module(s) to refactor.
• refactor_goal (required, string): what improves (e.g., reduce duplication, isolate side effects).
• constraints (optional, string[]): behavior must not change; performance bounds; compatibility.
• validation_commands (optional, string[]): tests/build/lint to run before/after.

Steps

1. Establish a baseline:
   • run existing tests (or add a minimal characterization test)
2. Identify refactor seam(s):
   • extract pure functions
   • isolate I/O
   • reduce global state
3. Apply refactor in small commits/patches:
   • one transformation per step
   • keep diffs readable
4. Re-run validations after each meaningful transformation.
5. If behavior changes, revert that change and adjust approach.

Validation

• Behavior is preserved (tests pass; outputs unchanged for known cases).
• Public interfaces remain stable (or are versioned/migrated explicitly).
• Complexity decreases measurably (smaller functions, fewer branches, less duplication).

Output

• refactor_summary
• files_changed
• behavior_guards (tests added/used)
• validation_results

Safety Rules

• Do not refactor without a behavior guard (tests or a deterministic reproduction).
• Avoid “big bang” rewrites.
• Do not change public APIs unless explicitly required.

Example

Goal: “Extract request validation from controller into validators/ and add unit tests.” Validation: pnpm test after each extraction step.