---

name: dont-repeat-yourself description: Use when writing similar code in multiple places. Use when copy-pasting code. Use when making the same change in multiple locations.

DRY (Don't Repeat Yourself)

Overview

Every piece of knowledge must have a single, unambiguous representation in the system.

If you find yourself writing the same logic twice, extract it. Duplication is a bug waiting to happen.

When to Use

• Writing code similar to existing code
• Copy-pasting and modifying
• Making the same change in multiple files
• Validation logic repeated across forms
• Same calculations in different places

The Iron Rule

CopyNEVER duplicate logic. Extract and reuse.

No exceptions:

• Not for "it's faster to copy"
• Not for "they're slightly different"
• Not for "I'll refactor later"
• Not for "it's just a few lines"

Detection: The Copy-Paste Smell

If you're about to copy code and modify it, STOP:

Copy// ❌ VIOLATION: Duplicated validation
function validateRegistrationEmail(email: string): boolean {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

function validateProfileEmail(email: string): boolean {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email); // Same logic!
}

// ✅ CORRECT: Single source of truth
function validateEmail(email: string): boolean {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

// Reuse everywhere
const isValidRegistration = validateEmail(regEmail);
const isValidProfile = validateEmail(profileEmail);

Detection: The "Change in Multiple Places" Test

If fixing a bug requires changing multiple locations, you have duplication:

Copy// ❌ Bug in tax calculation requires changes in 3 files
// cart.ts:      const tax = price * 0.08;
// checkout.ts:  const tax = price * 0.08;
// invoice.ts:   const tax = price * 0.08;

// ✅ Single source of truth
// tax.ts:       export const calculateTax = (price: number) => price * TAX_RATE;

The Correct Pattern: Extract and Parameterize

When code is "almost the same", extract the common part and parameterize the differences:

Copy// ❌ VIOLATION: Similar functions with minor differences
function formatUserName(user: User): string {
  return `${user.firstName} ${user.lastName}`;
}

function formatAdminName(admin: Admin): string {
  return `${admin.firstName} ${admin.lastName} (Admin)`;
}

// ✅ CORRECT: Parameterized
function formatName(person: { firstName: string; lastName: string }, suffix?: string): string {
  const name = `${person.firstName} ${person.lastName}`;
  return suffix ? `${name} (${suffix})` : name;
}

Pressure Resistance Protocol

1. "It's Faster to Copy"

Pressure: "I'll just copy this and modify it"

Response: Copying creates two places to maintain. Bugs will diverge.

Action: Extract shared logic first, then use it in both places.

2. "They're Slightly Different"

Pressure: "The functions are almost the same but not quite"

Response: "Almost the same" = extract common part, parameterize differences.

Action: Identify what's shared, extract it, make differences parameters.

3. "It's Just a Few Lines"

Pressure: "It's only 3 lines, not worth extracting"

Response: 3 lines duplicated 5 times = 15 lines to maintain. Bugs multiply.

Action: Extract even small duplications. Name them well.

4. "I'll Refactor Later"

Pressure: "Ship now, DRY it up later"

Response: You won't. Duplication spreads. DRY now takes 2 minutes.

Action: Extract before committing the duplication.

Red Flags - STOP and Reconsider

If you notice ANY of these, you're about to violate DRY:

• Ctrl+C / Ctrl+V in your workflow
• "This is similar to that other function"
• Same regex/validation in multiple places
• Identical error handling patterns repeated
• Same data transformation logic duplicated
• Constants defined in multiple files

All of these mean: Extract to a shared location.

Types of Duplication

Quick Reference

Common Rationalizations (All Invalid)

The Bottom Line

One piece of knowledge. One place in code.

When writing similar code: stop, find the existing code, extract if needed, reuse. Duplication is the root of maintenance nightmares.