# De Dupe

> Remove duplicated code and tech debt by keeping code DRY. Use when asked to de-duplicate logic, extract shared utilities, or refactor repeated patterns ("keep code DRY", "remove duplicated code", "extract common functions", "reduce tech debt"). Include checks for uncommitted changes before refactors.

- Skill: `majiayu000/de-dupe` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/de-dupe`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/de-dupe/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/de-dupe

---


# De-dupe and DRY Refactor

Follow a safe, repeatable workflow to find duplicated code, extract shared helpers, and reduce maintenance burden while preserving behavior.

## Workflow

1. Check for uncommitted changes before refactor.
   - Run `git status -sb` and note touched files.
   - If the tree is dirty, prefer working incrementally and avoid mixing unrelated changes.

2. Identify duplication targets.
   - Scan for obvious repeats in the touched files.
   - Use `rg` to find similar blocks or repeated strings.
     - Example: `rg -n "functionName|error message|regex literal" src/`
     - Example: `rg -n "(\w+\([^)]*\))" src/` then narrow to common blocks.

3. Decide if extraction is warranted.
   - Extract when logic is repeated 2+ times and the abstraction is stable.
   - Do not extract when it makes call sites harder to read or behavior diverges.

4. Extract shared utilities.
   - Create a small function with a focused signature.
   - Place in an existing shared module or create a new `utils`/`shared` file.
   - Keep side effects explicit and minimize hidden dependencies.

5. Replace duplicates.
   - Update call sites to use the new helper.
   - Remove redundant code and keep names consistent.

6. Verify behavior.
   - Update or add tests when behavior is non-trivial.
   - Run relevant tests or linters if available.

## Heuristics

- Prefer simple helpers over deep class refactors.
- Keep params explicit; avoid passing large context objects without need.
- Extract constants for repeated literals (strings, regexes, numbers).
- If duplication is across layers, consider moving logic to the lowest shared layer.

## Guardrails

- Avoid introducing new dependencies for small refactors.
- Do not change public APIs unless explicitly requested.
- Preserve performance characteristics; avoid extra allocations in hot paths.

## Notes for Codex

- Use `rg` for fast discovery and validate with context before editing.
- Keep the diff small and focused; do not mix refactors with unrelated changes.