I like defaults when they save time. I do not like them when they quietly turn into policy.
That is the bit people miss. A good default helps you move quickly at the start. A magical default helps until the day you need to understand why something is behaving the way it is. Then you are not looking at a decision anymore. You are looking at behavior that was baked in somewhere else.
That is usually where the pain starts.
Defaults are fine when they are obvious
I am not arguing against defaults in general. They are useful. They reduce setup friction, make tools easier to try, and keep simple cases simple.
If I am setting something up for the first time, I want the sensible thing to happen without a lot of ceremony.
The problem is not defaults themselves. The problem is when defaults stop being convenience and start being invisible control.
Once that happens, the system becomes harder to reason about. You think you are using the thing you configured, but you are actually using a chain of assumptions, fallbacks, and inherited values. That is fine right up until it is not.
Hidden policy is where the trouble lives
The reason I prefer explicit settings is simple: explicit settings show their work.
If I can see the value, I can change it. If I can change it, I can test it. If I can test it, I can trust it more.
Magical defaults often fail that chain. They hide the decision in a different layer, or in some other file, or in a platform convention nobody remembers until something breaks. Then the first question is not “what should this be?” It is “where is this even coming from?”
That is a bad place to start.
You end up with people fixing the symptom instead of the cause because the real configuration is too spread out or too implicit to inspect quickly. It does not feel like a big problem when the system is small. It feels annoying. Then the codebase grows, the team changes, and the annoyance turns into wasted time.
Explicit is usually easier to debug
For me, the biggest argument for explicit configuration is debugging.
When something is explicit, you can usually trace it in a straight line. The value is there. The setting is there. The behavior makes sense once you follow the path.
When something depends on too many defaults, the debugging path gets messy fast. You have environment variables, framework defaults, inherited values, old compatibility behavior, and maybe one special case from three versions ago that no one wants to touch.
That kind of setup is fragile because it works by agreement, not by clarity.
I would rather have a config file that looks slightly boring than a system that feels smart but needs a small detective story every time something changes.
Explicit also makes change safer
Another reason I prefer explicit settings is that they are easier to change safely.
If a value is written down, the change is visible in code review. If it is hidden in a default, the change is often invisible until the behavior shifts in production or in some environment nobody checked properly.
That matters because a lot of engineering work is really about controlling surprises. Explicitness reduces surprises. It makes the system less dependent on tribal knowledge and memory.
That is especially important in teams. One person may know the defaults well. The rest of the team probably does not. A system that only one person understands is already more expensive than it looks.
The real tradeoff
There is a tradeoff, of course. Too much explicit configuration can be noisy. Nobody wants a wall of boilerplate for things that genuinely should be left alone.
So I am not saying “never use defaults.” I am saying know when a default is just convenience and when it has become a hidden design decision.
If a setting affects behavior in a meaningful way, I usually want to see it. If it affects reliability, deployment, compatibility, or data handling, I want it spelled out even more.
That is not because I enjoy extra typing. It is because I value systems that are predictable under pressure.
My rule of thumb
If a default would be harmless to forget, I am fine with it.
If forgetting it would change behavior, create operational risk, or make debugging harder later, I want it explicit.
That line is not perfect, but it is a useful one. It keeps me from hiding important decisions behind convenience. And in practice, that usually makes the software easier to live with.