deslop-repo

Remove unused functions and simplify modules in the EZVals codebase.

1|Updated Aug 21, 2025
One-click install
npx skills add https://github.com/camronh/EZVals --skill deslop-repo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: deslop-repo
Source: https://github.com/camronh/EZVals/tree/main/.agents/skills/deslop-repo
Command: npx skills add https://github.com/camronh/EZVals --skill deslop-repo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

EZVals has accumulated technical debt and bloat that makes the codebase harder to understand and maintain. This Skill provides a disciplined approach to trimming unused code, simplifying modules, and preserving existing behavior and performance.

Core Features & Use Cases

  • Audit the codebase to identify dead code, redundant logic, and over-engineering that can be removed without affecting external behavior.
  • Incremental refactor to simplify large modules, extract essential functionality, and reduce noise while keeping interfaces stable.
  • Use Case: When preparing a release, you run this Skill to produce a leaner codebase with improved readability and maintainability, then run tests to confirm no regressions.

Quick Start

Run cleanup workflow locally and verify behavior with the existing integration tests.

Frequently Asked Questions about deslop-repo

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I clean up code bloat while preserving existing behavior?

To clean up code bloat while preserving behavior, audit the codebase to identify dead code, redundant logic, and over-engineering, then simplify modules incrementally while keeping public interfaces stable and verifying with integration tests.

What is the best way to remove unused functions before a release?

The best way to remove unused functions before a release is to perform an incremental refactor that trims dead code and reduces lines while running existing integration tests to confirm no regressions in external behavior.

Can I simplify large modules without altering functionality?

Yes, you can simplify large modules without altering functionality by extracting essential logic and reducing noise incrementally, ensuring that public interfaces remain stable and integration tests pass after each change.

Does test-driven code cleanup require integration tests?

Test-driven code cleanup requires integration tests to verify that removing unused functions and simplifying modules does not introduce regressions or alter the existing performance and public behavior.

Why does technical debt make a codebase harder to maintain?

Technical debt makes a codebase harder to maintain because accumulated bloat and redundant logic obscure essential functionality, requiring a disciplined audit to remove unused code and simplify modules for improved readability.

When do I need to refactor code for maintainability?

You need to refactor code for maintainability when preparing a release, allowing you to produce a leaner codebase by removing dead code and reducing noise while enforcing test-driven cleanup to confirm no regressions.