dry-logic-unifier

Identify duplicated logic patterns and extract them into shared utility packages.

Updated Mar 14, 2026
One-click install
npx skills add https://github.com/CaptainPhantasy/floyd-v5 --skill dry-logic-unifier
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dry-logic-unifier
Source: https://github.com/CaptainPhantasy/floyd-v5/tree/main/extensibility/skills/refactoring/dry-logic-unifier
Command: npx skills add https://github.com/CaptainPhantasy/floyd-v5 --skill dry-logic-unifier

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Duplicated or copy-pasted logic across multiple files leads to maintenance pain, inconsistent behavior, and bloated codebases.

Core Features & Use Cases

  • Identify duplicates: scan code to locate repeated logic patterns and utilities.
  • Extract & consolidate: factor out common logic into reusable utilities or packages.
  • Integrate cleanly: wire the new shared utilities into existing modules with minimal API surface and safety checks.

Quick Start

Identify duplicates and refactor by extracting shared logic into a reusable utility package for your codebase.

Frequently Asked Questions about dry-logic-unifier

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

FAQPage Schema
How do I identify duplicated logic patterns across multiple files for refactoring?

To identify duplicated logic for refactoring, scan your codebase to locate repeated utility implementations and patterns. This process highlights maintenance pain points caused by copy-pasted logic across modules.

What is the best way to extract shared utilities into a reusable package?

The best way to extract shared utilities is to factor out common logic into a clean, reusable package. This consolidation ensures consistent behavior and reduces codebase bloat during refactoring.

How do I integrate shared utilities into existing modules cleanly?

To integrate shared utilities cleanly, wire the new package into existing modules with minimal API surface and safety checks. This ensures consistent behavior without disrupting current codebase functionality.

Does modularization of code duplication work for large codebases requiring consistent utility implementations?

Modularization of code duplication works effectively for large codebases requiring consistent utility implementations. It abstracts repeated patterns into a shared utility package suitable for extensive refactoring efforts.

Why does copy-pasted logic across multiple files lead to codebase maintenance pain?

Copy-pasted logic leads to maintenance pain because it creates inconsistent behavior and bloated codebases. Unifying duplicated logic into a shared utility resolves these issues by providing a single source of truth.