TL;DR: Stop using the word "just." It’s not a technical term. It’s a psychological trap that turns clean systems into a mess of "quick fixes" that nobody (not even AI) can explain. Here is why "just" is the most expensive word in your codebase.
It’s 5:00 PM. The sprint is ending, there’s a bug in production, and someone on the call says: "Let’s just do it this way."
Whenever I hear the word "just" in a technical discussion, I get nervous. It usually doesn't mean the solution is simple. It means we are choosing to ignore how complex the problem actually is.
The "just" trap
We use the word "just" as a mental painkiller. It sounds easy. "Let's just add a flag here." "Let's just bypass this validation for now."
It feels like a quick win, but "just" isn't a technical term. It’s a psychological one. It’s a way to cut corners without feeling guilty about it. The problem is that code doesn't live in a vacuum. Every "just" you add has to live with all the other "justs" from last year.
Local simplicity, global mess
I call this the trap of local simplicity.
Imagine you are building a house. You need a socket in the middle of the room. Instead of doing the hard work and routing the wires properly, you "just" run an extension cord across the floor. Then you "just" cut a hole in the carpet so people don't trip. Then you "just" buy a smaller rug to cover the hole.
Individually, each step was "simple." But now you have a house where you can’t move the furniture because the whole system is a fragile mess of unrelated fixes.
In code, this creates a "tangle." Nothing is connected by logic. Everything is connected by history and hacks.
Why even AI can't save us here
A lot of people think AI will solve this. They think: "Even if the code is messy, AI will explain it to me."
But here is the catch: AI is great at understanding patterns and clean logic. It is terrible at understanding intent when there isn't any.
If your codebase is a pile of a thousand "justs," it has no clear intent. The AI can tell you what a specific line of code does, but it can't tell you why it’s there or why changing a status code in the billing module just broke the login page.
When we build systems out of random "quick fixes," we create something that is incomprehensible by design. Even for a machine.
The hidden cost
"Fast and simple" today is incredibly expensive tomorrow.
- The fear of change: the team becomes afraid to touch the code because nobody knows what might break.
- Onboarding hell: a new dev joins the team and instead of learning architecture, they have to learn "lore" and legends about why things are so weird.
- The maintenance tax: you spend 80% of your time fighting the "justs" of the past instead of building new things.
Let's stop saying it
I’m not saying we should never make compromises. Sometimes you have to ship fast.
But we should stop calling it "just."
Architecture isn't about writing clever code. It's about managing complexity. And "just" is the biggest lie we tell ourselves to avoid doing that work.
Top comments (0)