deslop

Remove duplication, dead code, weak types, and legacy paths from codebases.

Updated Mar 20, 2026
One-click install
npx skills add https://github.com/arjitj2/arjit-skills --skill deslop-arjitj2
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: deslop
Source: https://github.com/arjitj2/arjit-skills/tree/main/skills/deslop
Command: npx skills add https://github.com/arjitj2/arjit-skills --skill deslop-arjitj2

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you systematically improve an existing codebase when it has duplicated logic, weak typing, unused code, circular dependencies, legacy branches, defensive fallbacks, or AI-generated clutter that makes the project harder to maintain.

Core Features & Use Cases

  • Eight-lane cleanup workflow: Coordinates focused analysis across deduplication, shared types, dead code, cycles, type quality, error handling, legacy paths, and placeholder content.
  • Evidence-based refactoring: Encourages repo inspection, targeted research, and high-confidence changes instead of speculative rewrites.
  • Verification-driven maintenance: Uses typecheck, lint, tests, and dependency analysis to confirm cleanup work is safe.
  • Use Case: A team inherits a messy service with repeated utilities, circular imports, and any-heavy models, and uses this Skill to reduce complexity while preserving behavior.

Quick Start

Use the deslop skill to analyze the repository for dead code, weak types, legacy paths, and duplicated logic, then implement only the highest-confidence cleanup changes and verify them with the project’s checks.

Frequently Asked Questions about deslop

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

FAQPage Schema
How do I remove AI slop and clean up duplicated logic in a legacy codebase?

To remove AI slop and clean up a legacy codebase, you can coordinate an eight-lane analysis workflow covering deduplication, dead code, weak types, circular dependencies, and placeholder content, applying only high-confidence refactoring changes verified by typecheck and lint.

What's the best way to find and safely delete dead code without breaking existing behavior?

The best way to safely delete dead code is by inspecting the dependency graph and running static analysis to identify unused paths, then verifying removal with targeted tests and build validation to preserve existing behavior.

How does dependency graph inspection help with code cleanup and removing circular imports?

Dependency graph inspection helps code cleanup by mapping import cycles and unused modules, enabling evidence-based refactoring that eliminates circular dependencies while confirming structural integrity through type validation.

Can I use this approach for repository-wide maintenance on a service with weak typing and any-heavy models?

Yes, repository-wide maintenance specifically targets weak typing and any-heavy models by analyzing type quality lanes, strengthening shared types, and verifying improvements through typecheck and lint validation.

When should I avoid speculative rewrites during code refactoring?

You should avoid speculative rewrites during code refactoring when lacking sufficient repository evidence, prioritizing targeted research and static analysis to ensure high-confidence changes that pass typecheck and tests instead.