TL;DR: You should avoid storing stateless utility classes as instance variables initialized with new.

Problems 😔

• Hardcoded dependencies

• Testing difficulties

• High coupling

• Hidden side effects

• Rigid design

• Misleading intent

• Premature Optimization

• Stack clutter

Solutions 😃

1. Use dependency injection

2. Pass as parameter

3. Use static methods

4. Inline the logic

5. Use local variables

6. Inline object creation

Refactorings ⚙️

https://maxicontieri.substack.com/p/refactoring-024-replace-global-variables

https://maxicontieri.substack.com/p/refactoring-030-inline-attributes

https://maxicontieri.substack.com/p/refactoring-007-extract-class-5b0b5960d0e7

Context 💬

Hardcoding a stateless class in the constructor creates permanent coupling.

Even if the class is cheap to instantiate, you lose the ability to swap it.

Stateless objects shouldn't be part of the object's internal state.

You confuse readers by making a tool look essential to the object's identity.

It makes testing harder because you can't mock the hardcoded dependency.

Sample Code 💻

Wrong 🚫

class UserProcessor {
  private provider: MockDataProvider;

  constructor() {
    // You hardcode the dependency here.
    // This makes the class harder to test.
    this.provider = new MockDataProvider();
  }

  process(data: any) {
    return this.provider.format(data);
  }
}

Right 👉

interface DataProvider {
  format(data: any): any;
}

class UserProcessor {
  // You inject the dependency via constructor.
  // Now you can swap it or mock it easily.
  constructor(private readonly provider: DataProvider) {}

  process(data: any) {
    return this.provider.format(data);
  }
}

// Simpler but coupled
 class UserProcessor {
    constructor() {
      // Empty
    }
  
    process(data: any) {
      return new MockDataProvider().format(data);
    }
  }

Detection 🔍

Look for the new keyword inside constructors.

Watch for private properties instantiated directly in the constructor rather than passed as parameters.

Most linters flag this pattern automatically when you create instances and assign them to private fields without dependency injection.

Tags 🏷️

• Premature Optimization

Level 🔋

[X] Beginner

Why the Bijection Is Important 🗺️

Software should mimic a MAPPER of the real world.

In reality, a worker might use a tool to complete a task.

The tool is not a permanent physical attachment to the worker.

When you refactor to use dependency injection, you respect the bijection by treating collaborators as external entities, not internal state.

This keeps your simulation flexible and accurate.

AI Generation 🤖

AI generators frequently create this smell.

They often suggest code that just works by instancing dependencies directly in the constructor to save time.

AI Detection 🧲

AI can easily detect this smell without explicit instructions.

When you show AI a class with new keywords in the constructor, it recognizes the pattern as hardcoded coupling.

AI identifies that stateless utility classes should be injected rather than instantiated internally.

The detection is straightforward because the pattern is syntactically obvious and semantically harmful.

Try Them! 🛠

Remember: AI Assistants make lots of mistakes

Suggested Prompt: remove the cached attribute

Without Proper Instructions	With Specific Instructions
ChatGPT	ChatGPT
Claude	Claude
Perplexity	Perplexity
Copilot	Copilot
You	You
Gemini	Gemini
DeepSeek	DeepSeek
Meta AI	Meta AI
Grok	Grok
Qwen	Qwen

Conclusion 🏁

Storing stateless dependencies as instance variables makes your code rigid.

When you inject these dependencies instead, you improve testability and keep your objects focused on their true purpose.

Relations 👩‍❤️‍💋‍👨

https://maxicontieri.substack.com/p/code-smell-06-too-clever-programmer-bffec35daf0b

https://maxicontieri.substack.com/p/code-smell-20-premature-optimization-60409b7f90ec

Disclaimer 📘

Code Smells are my opinion.

Credits 🙏

Photo by Possessed Photography on Unsplash

---

Coupling is the enemy of change

Rich Hickey

https://maxicontieri.substack.com/p/software-engineering-great-quotes-3af63cea6782

---

This article is part of the CodeSmell Series.

https://maxicontieri.substack.com/p/how-to-find-the-stinky-parts-of-your-code-fa8df47fc39c