Stop Writing the Same Code Twice: Master Code Deduplication in JavaScript/TypeScript Projects

Tired of maintaining identical functions scattered across your codebase? Spending hours debugging the same logic in six different files? Your development velocity is being crushed by code duplication, and every "quick copy-paste" is technical debt that compounds daily.

The Hidden Cost of Duplicate Code

Code duplication isn't just about file size—it's a productivity killer that creates cascading problems:

• Bug Multiplication: Fix a bug in one place, miss it in five others. Your users report the same issue repeatedly.
• Feature Paralysis: Adding a new parameter to a function means hunting down every duplicate and hoping you don't miss any.
• Maintenance Nightmare: Simple changes become archaeological expeditions through your codebase.
• Code Review Friction: Reviewers spot suspicious similarities but lack tools to quantify the duplication.

Real scenario: A payment validation function exists in 8 different components. A security vulnerability requires an urgent patch. You find and fix 7 instances. The 8th one ships to production. Sound familiar?

Transform Your Codebase with Systematic Deduplication

These Cursor Rules implement a comprehensive deduplication strategy that catches duplicates before they ship, extracts reusable patterns automatically, and maintains code quality through automated scanning. Instead of playing whack-a-mole with duplicate code, you'll build a self-maintaining codebase that scales cleanly.

The rules integrate battle-tested tools (SonarQube, ESLint plugins) with intelligent refactoring patterns, giving you both prevention and cure for code duplication.

Key Benefits: Measurable Development Acceleration

Reduce Debugging Time by 60%: Fix bugs once, everywhere. No more hunting through similar-looking functions wondering which one has the latest fix.

Cut Feature Development Time in Half: Add new functionality to centralized utilities instead of copy-pasting and modifying across multiple files.

Eliminate "Copy-Paste" Code Reviews: Automated scanning catches duplicates in CI, so code reviews focus on logic instead of spotting similarities.

Improve Code Coverage Without Writing More Tests: Extract shared logic into testable utilities—one test suite covers multiple use cases.

Real Developer Workflows: Before and After

Before: Feature Addition Chaos

// Component A
const formatUserDate = (date: Date): string => {
  return date.toLocaleDateString('en-US', { 
    year: 'numeric', month: 'short', day: 'numeric' 
  });
};

// Component B  
const displayDate = (date: Date): string => {
  return date.toLocaleDateString('en-US', { 
    year: 'numeric', month: 'short', day: 'numeric' 
  });
};

// Component C
const showFormattedDate = (date: Date): string => {
  return date.toLocaleDateString('en-US', { 
    year: 'numeric', month: 'short', day: 'numeric' 
  });
};

Adding timezone support means updating 47 similar functions. Miss one, break production.

After: Centralized, Tested, Scalable

// @/utils/date.ts
export const formatDate = (date: Date, options?: Intl.DateTimeFormatOptions): string => {
  const defaultOptions = { year: 'numeric', month: 'short', day: 'numeric' };
  return date.toLocaleDateString('en-US', { ...defaultOptions, ...options });
};

// Usage everywhere
import { formatDate } from '@/utils/date';
const displayText = formatDate(userDate); // Add timezone support once, works everywhere

One function, one test suite, one place to add features. Your SonarQube dashboard shows zero duplicated blocks.

Error Handling: From Scattered Catch Blocks to Centralized Strategy

Before: Exception handling copy-pasted across API calls

// In 15 different service files
try {
  const result = await apiCall();
  return result.data;
} catch (error) {
  console.error('API call failed:', error);
  if (error.status === 401) {
    redirectToLogin();
  }
  throw new Error('Something went wrong');
}

After: Centralized error handling with typed exceptions

// @/utils/errors.ts  
export class APIError extends Error {
  constructor(message: string, public code: string, public originalError?: Error) {
    super(message);
    this.stack = originalError?.stack;
  }
}

export const withErrorHandling = <T>(apiCall: () => Promise<T>) => async (): Promise<T> => {
  try {
    return await apiCall();
  } catch (error) {
    if (error.status === 401) redirectToLogin();
    throw new APIError('API call failed', 'API_ERROR', error);
  }
};

// Usage
const fetchUser = withErrorHandling(() => api.get('/user'));

Implementation Guide: Set Up Automated Deduplication

Step 1: Configure Your Deduplication Scanner

Add SonarQube integration to your CI pipeline:

# .github/workflows/quality.yml
- name: SonarQube Scan
  uses: SonarSource/sonarcloud-github-action@v1
  with:
    args: >
      -Dsonar.duplicatedLines.threshold=3
      -Dsonar.duplicatedBlocks.threshold=2
  env:
    SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

Step 2: Enable ESLint Duplication Detection

// .eslintrc.js
{
  "extends": ["plugin:sonarjs/recommended"],
  "rules": {
    "sonarjs/no-duplicate-string": ["error", { "threshold": 3 }],
    "sonarjs/no-identical-functions": "error",
    "no-duplicate-imports": "error"
  }
}

Step 3: Install the Cursor Rules

Copy the rules into your .cursorrules file and restart Cursor. The AI will now:

• Suggest extracting duplicate patterns during code review
• Recommend creating shared utilities when it detects repetition
• Enforce TypeScript strict mode to catch duplicate type definitions
• Guide you through proper abstraction without over-engineering

Step 4: Set Quality Gates

Configure your CI to fail on new duplication:

// sonar-project.properties
sonar.qualitygate.wait=true
sonar.coverage.exclusions=**/*.test.ts
sonar.cpd.exclusions=**/types.ts

Results & Impact: Quantified Productivity Gains

Week 1: Cursor identifies 23 duplicate functions in your React components. You extract them into 6 reusable hooks. Code review time drops by 40%.

Month 1: Your SonarQube dashboard shows 90% reduction in duplicated blocks. Bug fix deployments go from 4 files changed to 1 file changed.

Month 3: New features require 50% fewer lines of code because you're composing existing utilities instead of writing from scratch. Your test coverage improves because shared utilities have dedicated test suites.

Developer Feedback: "I used to dread refactoring because I never knew what I'd break. Now the scanner catches duplicates automatically, and I can extract common patterns confidently."

Your codebase becomes self-improving—each extraction makes future development faster. Instead of fighting technical debt, you're building reusable assets that accelerate every subsequent feature.

Stop writing the same code twice. Your future self will thank you, your code reviewers will thank you, and your production deployments will be more reliable. The rules are waiting in your .cursorrules file.