How do I install the Routine Dup Unifier skill?

Run npx skillmds@latest add bex-co/routine-dup-unifier-2 in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Routine Dup Unifier safe to use?

This skill has not completed SkillMD's automated safety review yet. Independent scanners report: SkillSpector: PASS, Skill Scanner: PASS. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Routine Dup Unifier?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Routine Dup Unifier free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Routine Dup Unifier?

bex-co (@bex-co) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Routine Dup Unifier by bex-co — Agent Skill

Name: Routine Dup Unifier
Author: bex-co

Routine Dup Unifier

Autonomous maintenance routine that finds duplicated implementations of the same logic within one monorepo package, merges them into the single best copy, repoints every caller, deletes the rest, and ships each unification via /ship. Use only when the user explicitly invokes /routine-dup-unifier or asks to merge/deduplicate duplicated code. SKIP for code with no remaining callers (routine-dead-code-removal), needless indirection around a single implementation (routine-abstraction-improver), and duplication across two packages — that is reported, never merged. The core trigger is "these are two copies of the same logic; make them one".

bex-co Updated Sep 22, 2026

File contents

Task: Merge duplicated implementations into one

Usage: /routine-dup-unifier [package-or-path]

Find two (or more) live copies of the same logic inside one package, prove they are semantically the same, keep the best one, repoint all callers, delete the rest, and ship via /ship.

Contract

Read .agents/skills/routine-shared/contract.md first — preconditions, scope resolution, verify gates, ship protocol, budget, universal STOPs. Floor even without it: never ship red; one finding per ship; anything in a DO_NOT_DO.md is a hard STOP.

Workflow

1. Scope

Resolve scope per the contract. Duplication is a within-one-package concern here; never widen scope mid-run.

2. Discover

Agent-driven search — Grep for repeated names, similar signatures, and shared distinctive string literals (error messages, format strings, regexes); read sibling directories that grew in parallel (helpers/utils files, per-screen copies of formatting or validation logic). Optional accelerator with no new dependency: npx --yes jscpd --min-tokens 50 <pkg>/src --output <pkg>/tmp/ (output stays in the gitignored tmp/).

3. Prove it

Read every copy end to end — name similarity is not proof.
Semantics must be identical, or differ only in ways trivially covered by a parameter that keeps the survivor simpler than the sum of the copies.
The intended survivor is test-covered for the behavior all callers rely on; if not, write those tests first (they are part of the finding).

4. Fix

Keep the better copy (better tested, more used, better placed). Port any unique behavior from the losers, repoint every caller, delete the losers, and move over any tests that pinned loser-only behavior worth keeping. Re-run the package's dead-code detector (yarn lint:deadcode / make deadcode) to confirm nothing was orphaned.

5. Verify

Owning package's full gate per the contract.

6. Ship

Compose /ship for this one unification. Loop within budget.

What NOT to do

Never merge across packages. Packages are independent by repo rule (no new cross-package imports). Cross-package duplication goes in the summary as a report, nothing more.
If unification requires an abstraction more complex than either original (config objects, strategy callbacks, mode flags), skip the finding — a slightly duplicated simple thing beats a unified complicated one.
Never delete a copy before every caller is repointed and green.
The deliberate clean-room reimplementations noted in .pm/DO_NOT_DO.md (e.g. fava-slim vs vendored fava) are not duplication findings.

Arguments

$ARGUMENTS

---name: routine-dup-unifier-2description: Autonomous maintenance routine that finds duplicated implementations of the same logic within one monorepo package, merges them into the single best copy, repoints every caller, deletes the rest, and ships each unification via /ship. Use only when the user explicitly invokes /routine-dup-unifier or asks to merge/deduplicate duplicated code. SKIP for code with no remaining callers (routine-dead-code-removal), needless indirection around a single implementation (routine-abstraction-improver), and duplication across two packages — that is reported, never merged. The core trigger is "these are two copies of the same logic; make them one".---# Task: Merge duplicated implementations into oneUsage: `/routine-dup-unifier [package-or-path]`Find two (or more) live copies of the same logic inside one package, prove theyare semantically the same, keep the best one, repoint all callers, delete therest, and ship via `/ship`.## ContractRead `.agents/skills/routine-shared/contract.md` first — preconditions,scope resolution, verify gates, ship protocol, budget, universal STOPs. Flooreven without it: never ship red; one finding per ship; anything in a`DO_NOT_DO.md` is a hard STOP.## Workflow### 1. ScopeResolve scope per the contract. Duplication is a **within-one-package** concernhere; never widen scope mid-run.### 2. DiscoverAgent-driven search — Grep for repeated names, similar signatures, and shareddistinctive string literals (error messages, format strings, regexes); readsibling directories that grew in parallel (helpers/utils files, per-screencopies of formatting or validation logic). Optional accelerator with no newdependency: `npx --yes jscpd --min-tokens 50 <pkg>/src --output <pkg>/tmp/`(output stays in the gitignored `tmp/`).### 3. Prove it- Read every copy **end to end** — name similarity is not proof.- Semantics must be identical, or differ only in ways trivially covered by a parameter that keeps the survivor simpler than the sum of the copies.- The intended survivor is test-covered for the behavior all callers rely on; if not, write those tests first (they are part of the finding).### 4. FixKeep the better copy (better tested, more used, better placed). Port anyunique behavior from the losers, repoint every caller, delete the losers, andmove over any tests that pinned loser-only behavior worth keeping. Re-run thepackage's dead-code detector (`yarn lint:deadcode` / `make deadcode`) toconfirm nothing was orphaned.### 5. VerifyOwning package's full gate per the contract.### 6. ShipCompose `/ship` for this one unification. Loop within budget.## What NOT to do- **Never merge across packages.** Packages are independent by repo rule (no new cross-package imports). Cross-package duplication goes in the summary as a report, nothing more.- If unification requires an abstraction more complex than either original (config objects, strategy callbacks, mode flags), skip the finding — a slightly duplicated simple thing beats a unified complicated one.- Never delete a copy before every caller is repointed and green.- The deliberate clean-room reimplementations noted in `.pm/DO_NOT_DO.md` (e.g. `fava-slim` vs vendored fava) are not duplication findings.## Arguments$ARGUMENTS

Frequently asked questions