Comprehensive Reducing Module

A practical skill for reducing complexity in software systems — covering code simplification, dependency reduction, API surface minimization, configuration consolidation, and systematic elimination of unnecessary abstraction layers.

When to Use This Skill

Choose Comprehensive Reducing Module when you need to:

• Simplify overly complex code without changing behavior
• Reduce dependency count in a project
• Minimize API surface area for maintainability
• Consolidate scattered configuration into fewer sources
• Remove unnecessary abstraction layers and indirection

Consider alternatives when:

• You need performance optimization (use a performance skill)
• You need architecture redesign (use an architecture skill)
• You need refactoring patterns (use a refactoring skill)

Quick Start

Copy
# Analyze a codebase for reduction opportunities
claude "Analyze this Node.js project for complexity reduction. Look for: unnecessary dependencies, over-abstracted code, redundant configuration, and dead code."

Copy
# Complexity Reduction Analysis

## Dependencies (package.json)
| Package      | Used For        | Reduction Opportunity        |
|-------------|-----------------|------------------------------|
| lodash      | 3 functions     | Replace with native JS       |
| moment      | Date formatting | Replace with date-fns or Intl|
| axios       | 2 API calls     | Replace with native fetch    |
| uuid        | ID generation   | Replace with crypto.randomUUID() |
| dotenv      | Env loading     | Keep (essential)             |

**Reducible**: 4 dependencies → 0 (use native alternatives)
**Savings**: ~2MB from node_modules

## Code Complexity
| File               | Issue                  | Reduction                  |
|-------------------|------------------------|----------------------------|
| src/utils/helpers.ts | 15 functions, 8 unused | Delete 8 unused functions |
| src/config/index.ts  | 3 config files merged  | Single config source      |
| src/api/client.ts    | Wrapper around fetch   | Use fetch directly        |
| src/types/index.ts   | 40 types, 12 unused    | Delete 12 unused types    |

## Abstraction Layers
| Layer              | Purpose            | Verdict                    |
|-------------------|---------------------|----------------------------|
| APIClient class   | Wraps fetch         | Remove — fetch is fine      |
| Logger wrapper    | Wraps console.log   | Remove — use console directly|
| ConfigManager     | Reads .env          | Remove — use process.env    |
| DatabaseAdapter   | Wraps Prisma        | Keep — useful abstraction   |

Core Concepts

Reduction Targets

Target	Signs of Excess	Reduction Strategy
Dependencies	> 50% unused exports	Replace with native code
Abstractions	Wrappers that add no value	Inline the wrapped code
Configuration	5+ config files for one app	Consolidate to 1-2 files
Types/Interfaces	Types used in only one place	Inline the type
API Surface	Public methods nobody calls	Make private or delete
Code Paths	Features nobody uses	Feature-flag then remove

Dependency Reduction

Copy
// BEFORE: lodash for simple operations
const _ = require("lodash");
const unique = _.uniq(items);
const grouped = _.groupBy(items, "category");
const picked = _.pick(obj, ["name", "email"]);

// AFTER: Native JavaScript equivalents
const unique = [...new Set(items)];
const grouped = Object.groupBy(items, item => item.category);
const { name, email } = obj;
const picked = { name, email };

// BEFORE: moment for date formatting
const moment = require("moment");
const formatted = moment().format("YYYY-MM-DD");

// AFTER: Native Intl or simple formatting
const formatted = new Date().toISOString().split("T")[0];

// BEFORE: uuid for ID generation
const { v4: uuidv4 } = require("uuid");
const id = uuidv4();

// AFTER: Native crypto
const id = crypto.randomUUID();

Abstraction Reduction

Copy
// BEFORE: Unnecessary wrapper class
class APIClient {
  constructor(baseURL) { this.baseURL = baseURL; }
  async get(path) {
    const res = await fetch(`${this.baseURL}${path}`);
    return res.json();
  }
  async post(path, data) {
    const res = await fetch(`${this.baseURL}${path}`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(data),
    });
    return res.json();
  }
}

// Usage
const client = new APIClient("https://api.example.com");
const users = await client.get("/users");

// AFTER: Direct fetch (no wrapper needed for 2 endpoints)
const API_BASE = "https://api.example.com";
const users = await fetch(`${API_BASE}/users`).then(r => r.json());

Configuration

Parameter	Description	Example
target	What to reduce	"dependencies" / "code"
aggressiveness	How aggressively to reduce (1-5)	3 (moderate)
preserve	Things to never remove	["database", "auth"]
dry_run	List changes without applying	true
include_metrics	Show before/after metrics	true

Best Practices

1. Delete dead code immediately, don't comment it out — Commented-out code is noise that never gets cleaned up. Git preserves history — if you need it back, it's in a previous commit. Delete it and move on.

2. Replace dependencies with native alternatives when possible — Every dependency is a maintenance burden (security updates, breaking changes, bundle size). If native JavaScript can do what lodash does for your 3 use cases, drop the dependency.

3. Measure complexity before and after reduction — Track metrics: dependency count, lines of code, number of files, bundle size. "We removed 4 dependencies and 800 lines of dead code" is a concrete result that justifies the effort.

4. Reduce one layer at a time — Don't rewrite 5 abstraction layers simultaneously. Remove one unnecessary wrapper, verify nothing breaks, then move to the next. Sequential reduction with verification is safer than big-bang simplification.

5. Ask "what happens if I delete this?" before refactoring — Sometimes the simplest reduction is deletion. If a function, file, or dependency can be removed and nothing breaks, that's the ideal reduction. Don't refactor what you should delete.

Common Issues

Removing an abstraction breaks tests that mock it — If tests mock your APIClient class, removing the class breaks tests even if the production code works fine. Update tests first to test behavior (not mocks), then remove the abstraction.

Dependency removal introduces subtle behavior differences — lodash's _.isEqual and JavaScript's === behave differently for objects. When replacing dependencies, test edge cases thoroughly. The native alternative may not handle every case the library did.

Reducing too aggressively makes code harder to extend — A function that handles 3 use cases today might need to handle 5 tomorrow. Reduce based on current needs but consider whether the abstraction might be genuinely useful soon. Don't remove the database adapter "because we could just use Prisma directly" if you might switch databases.