Bad code doesn’t always crash your app — sometimes it just silently rots it from the inside. Here are 12 code smells you need to fix before they kill your project.

---

Introduction: What’s a Code Smell?

Not every bug is a crash. Sometimes the danger is hidden: code that works today but becomes unmaintainable tomorrow.

These are called code smells — subtle signs that your codebase is starting to rot. They don’t stop execution, but they make your project harder to read, extend, and debug.

Think of them like weird smells in your kitchen. Nothing’s on fire (yet), but something’s definitely off.

In this guide, we’ll cover 12 common code smells you’ll see in JavaScript/React/Node projects, along with clear fixes to keep your code healthy.

---

1. Long Functions

Smell: A single function that scrolls forever, doing too many things.

function processOrder(order) {
  validate(order);
  calculateDiscount(order);
  updateInventory(order);
  sendEmail(order);
  logOrder(order);
  // ... 50 more lines
}

Fix: Break it down into smaller functions (SRP — Single Responsibility Principle).

function processOrder(order) {
  validate(order);
  applyDiscount(order);
  persist(order);
  notify(order);
}

---

2. Magic Numbers & Strings

Smell: Hard-coded constants sprinkled everywhere.

if (status === 3) { ... }

Fix: Replace with named constants or enums.

const STATUS = { PENDING: 1, SHIPPED: 2, DELIVERED: 3 };

if (status === STATUS.DELIVERED) { ... }

---

3. Copy-Paste Code

Smell: Same block of code repeated across files.

if (user.age > 18) {
  return true;
}
// ... same check in 4 different places

Fix: Extract into a reusable function or utility.

const isAdult = user => user.age > 18;

---

4. God Objects / God Components

Smell: One component or class does everything.

function Dashboard() {
  // fetch data
  // manage state
  // render UI
  // handle routing
}

Fix: Split into smaller, focused components.

---

5. Deep Nesting

Smell: Code buried in multiple if/else or callbacks.

if (a) {
  if (b) {
    if (c) {
      doSomething();
    }
  }
}

Fix: Use early returns or guard clauses.

if (!a || !b || !c) return;
doSomething();

---

6. Too Many Parameters

Smell: Functions with 5–6+ parameters.

function createUser(name, age, address, city, zip, phone, email) { ... }

Fix: Use an object parameter.

function createUser({ name, age, address, city, zip, phone, email }) { ... }

---

7. Boolean Flags

Smell: Functions that behave differently based on a flag.

function saveUser(user, isAdmin) {
  if (isAdmin) { ... } else { ... }
}

Fix: Split into separate functions.

function saveAdmin(user) { ... }
function saveRegularUser(user) { ... }

---

8. Hidden Temporal Coupling

Smell: Functions that must be called in a specific order.

db.connect();
db.setSchema();
db.query("...");

Fix: Enforce order through higher-level abstractions.

const db = new Database().withSchema("users");
db.query("...");

---

9. Ignoring Errors

Smell: Empty catch blocks or swallowed errors.

try {
  riskyOperation();
} catch (e) {
  // ignore
}

Fix: Handle errors properly or at least log them.

catch (e) {
  console.error("Error processing order:", e);
}

---

10. Overuse of Comments

Smell: Comments explaining what the code does, instead of writing self-explanatory code.

// Add 1 to index
i = i + 1;

Fix: Write cleaner code, use meaningful names.

index++;

Comments should explain why, not what.

---

11. Tight Coupling

Smell: Modules that depend heavily on each other.

// UserService.js
import { sendEmail } from "./EmailService.js";

Fix: Use dependency injection or abstractions.

class UserService {
  constructor(emailService) {
    this.emailService = emailService;
  }
}

---

12. Ignoring Tests

Smell: Code changes without tests = bugs waiting to happen.

Fix: Write small, focused unit tests.

test("isAdult returns true for age > 18", () => {
  expect(isAdult({ age: 20 })).toBe(true);
});

---

Wrapping It All Up

Here are the 12 code smells to watch for:

1. Long functions
2. Magic numbers/strings
3. Copy-paste code
4. God objects/components
5. Deep nesting
6. Too many parameters
7. Boolean flags
8. Temporal coupling
9. Ignored errors
10. Overuse of comments
11. Tight coupling
12. No tests

👉 Bottom line: Code smells aren’t bugs today — but they’re bugs waiting to happen tomorrow. Fix them early, and your project will scale much smoother.

---

Call to Action

👉 Which of these code smells have you spotted in your own project? Drop a comment 👇.

📤 Share this with your teammates — chances are, they’re guilty of one too.
🔖 Bookmark this post as your personal code quality checklist.