dry-consolidation

DRY Consolidation

Systematic extraction of duplicated code into shared, tested abstractions.

When to Use This Skill

Use this skill when... Use these instead when...

Multiple files have identical/near-identical code blocks Single file needs cleanup → /code:refactor

Copy-pasted utility functions across components Looking for anti-patterns without fixing → /code:antipatterns

Repeated UI patterns (dialogs, pagination, error states) Functional refactoring of a file or directory → /code:refactor

Duplicated hooks or state management boilerplate Structural code search only → ast-grep-search

Import blocks are bloated from repeated inline patterns Linting/formatting issues → /lint:check

Context

Target path: !echo "$1"
Project type: !find . -maxdepth 1 ( -name "package.json" -o -name "Cargo.toml" -o -name "pyproject.toml" -o -name "go.mod" )
Source directories: !find . -maxdepth 1 -type d ( -name "src" -o -name "lib" -o -name "app" -o -name "components" -o -name "packages" )
Test framework: !find . -maxdepth 2 ( -name "vitest.config." -o -name "jest.config." -o -name "pytest.ini" -o -name "conftest.py" )
Existing shared utilities: !find . ( -path "/lib/" -o -path "/utils/" -o -path "/shared/" -o -path "/common/" -o -path "/hooks/" ) -type f -print -quit

Parameters

$1 : Path or directory to scan (defaults to src/ )
--scope : Focus on a specific extraction type: utilities , components , hooks , or all (default: all )
--dry-run : Analyze and report duplications without making changes

Execution

Execute this 7-step consolidation workflow. Use TodoWrite to track each extraction as a separate task.

Step 1: Scan for duplicated patterns

Scan the target path for duplicated patterns. Search for these duplication signals:

Identical function bodies:

Grep for function/method signatures that appear in multiple files. Look for identical multi-line blocks (3+ lines) across files.

Repeated inline patterns:

Utility functions defined identically in multiple files (string truncation, date formatting, validation)
Identical error handling blocks (try/catch patterns, error state JSX)
Copy-pasted UI fragments (pagination controls, confirmation dialogs, loading states)
Repeated hook/state management patterns (delete confirmation + mutation + handler)
Duplicated import blocks that signal repeated inline implementations

Search strategy:

Use Grep to find repeated function names, variable patterns, and import clusters
Use Glob to identify files with similar structure (e.g., all *List.tsx , all *Detail.tsx )
Read candidate files to confirm duplication and measure scope

Step 2: Classify duplications

Group discovered duplications into extraction categories:

Category Extract Into Location Convention

Utilities Pure functions src/lib/utils/ or src/utils/

Components Shared UI components src/components/ui/ or src/components/shared/

Hooks Custom React/Vue hooks src/hooks/ or src/composables/

Types Shared type definitions src/types/ or alongside the abstraction

Follow the project's existing conventions for shared code location. If no convention exists, propose one based on the framework.

Step 3: Plan extractions

For each duplication cluster, plan the extraction:

Name the abstraction — Use a clear, descriptive name that reflects the shared behavior
Define the interface — Determine parameters needed to cover all usage variations
Choose the location — Follow project conventions for shared code placement
List all consumers — Identify every file that will be updated
Assess risk — Note any subtle differences between duplicated instances that need parameterization

Present the plan to the user before proceeding (unless --dry-run was not specified and the scope is clear).

Plan format:

Extraction Plan

1. [Abstraction Name] → [target file path]

Type: utility | component | hook
Replaces: [N] identical blocks across [M] files
Consumers: [list of files]
Parameters: [any variations that need to be parameterized]
Estimated lines saved: [N]

Step 4: Extract shared abstractions

Execute each planned extraction:

Create the shared abstraction with proper typing and documentation
Replace each instance in consumer files with an import + usage of the new abstraction
Handle variations — parameterize differences between instances rather than creating multiple abstractions
Update imports — add the new import, remove imports that were only needed for the inline version

Extraction order: Start with utilities (no dependencies), then components, then hooks (may depend on utilities/components).

Mark each extraction as completed in the todo list before moving to the next.

Step 5: Write tests

Write tests for each extracted abstraction:

Abstraction Type Test Approach

Utility function Unit tests covering all input variations, edge cases

UI component Render tests, prop variations, accessibility

Custom hook Hook testing with mock dependencies, state transitions

Type definitions Type-level tests if applicable (tsd, expect-type)

Place test files adjacent to the abstraction or in the project's test directory, following existing conventions.

Step 6: Clean up dead code

After all extractions are complete:

Remove unused imports from all updated consumer files
Remove dead code — inline helper functions that are now replaced
Verify no orphaned references — search for any remaining references to removed code

Step 7: Verify all checks pass

Run the full verification suite:

TypeScript/JavaScript projects:

npx tsc --noEmit # Type checking npm run lint # Linting (or biome/eslint directly) npm run test # Full test suite

Python projects:

ty check . # Type checking ruff check . # Linting pytest # Test suite

Rust projects:

cargo check # Type checking cargo clippy # Linting cargo test # Test suite

All three must pass. If any fail, fix the issues before reporting completion.

Output Summary

After all phases complete, report: