Open your favorite AI coding agent and you’re greeted with a surprising number of decisions. Which model should you use? Should reasoning be low, medium, or high? How much context should the agent load? Which MCP servers should be enabled, which skills should it have access to, and should it ask before running commands?

Most of us don’t know the right answers. We pretend we do, but if we’re honest, we usually pick whatever worked last time or leave the defaults untouched. The strange thing is that we don’t consider this a problem. We accept it as the cost of using cutting-edge AI, while actually, it’s a sign that the technology hasn’t matured yet.

A brief history of hiding complexity

The first cars expected drivers to know far more than they do today. You adjusted the choke before starting the engine, you watched gauges that most drivers today have never heard of, and if something sounded wrong, you diagnosed it yourself.

Modern cars are dramatically more sophisticated. They manage fuel injection, traction control, anti-lock braking, adaptive cruise control, and increasingly parts of the driving itself. Yet despite all that added sophistication, the driver makes fewer decisions than ever before. The technology became more complex and the experience became simpler.

The same thing happened with cameras, computers, and smartphones. As products mature, implementation details disappear behind intent. You no longer tell the product how to do something. You tell it what you want to accomplish.

Simplicity isn’t about removing features

People often confuse simplicity with minimalism. A modern car has vastly more capabilities than one from fifty years ago. An iPhone has incomparably more features than the first mobile phones. So if it’s not about features, what is it about then? Responsibility.

The product has taken responsibility for decisions that users previously had to make themselves. That’s what “it just works” really means. The problem stayed just as hard, but someone else got good enough at solving it for you.

Configuration is a form of uncertainty

Every implementation setting exposed to the user represents a decision that the product wasn’t yet confident enough to make on the user’s behalf.

Notice the qualifier: implementation. Not every choice belongs to the product. Whether I prefer dark mode or light mode is a personal preference. Whether I want notifications is a personal preference. Those choices should stay mine.

But asking me which reasoning level to use? Or which model, or which context window? Those are implementation details dressed up as choices. Most users aren’t qualified to answer those questions, and they shouldn’t have to.

Why we still need all these knobs

To be clear, today’s AI products are being honest about what they don’t know. An AI agent doesn’t yet know whether I’m prototyping or fixing production, whether I care more about speed or quality, or whether this repository is mission critical. It doesn’t know whether I prefer concise or comprehensive solutions, or whether I value lower cost over a marginally better result.

Lacking that understanding, it delegates those decisions to me. Configuration compensates for missing understanding.

Better defaults won’t fix this

Many people assume the solution is better defaults. I don’t think that’s enough. A single default can never know my situation. The real evolution is contextual judgment.

Imagine asking:

Refactor issue #123.

Instead of immediately asking you which model to use or which reasoning mode to enable, the agent begins by understanding the problem. It reads the issue, explores the repository, discovers the relevant code, and identifies dependencies. If something important is ambiguous, it asks.

I assume backward compatibility matters because this modifies a public API. Is that correct?

Notice, that the agent isn’t asking implementation questions. It’s validating assumptions about your intent. Once it understands the task, it quietly configures itself. Maybe it picks a small model to classify the problem, a larger reasoning model for the architectural decisions, and a fast model to update documentation before a verifier checks the pull request. Those decisions shouldn’t be mine. They’re part of the agent’s job.

Product judgment

This reveals something broader about product design. It’s easy to remove options. Any product team can hide an advanced menu. What’s difficult is removing choices without removing capability.

That requires something much harder than simplification. It requires judgment, and judgment comes from experience, empathy, telemetry, and thousands of interactions with real users. The best product teams don’t remove settings because they dislike configuration. They remove settings because they’ve learned enough to make better decisions than their users would have made themselves. They’ve earned that confidence.

AI is following a familiar pattern

Back in the 1990s, computer magazines compared processor clock speeds, RAM, hard drive capacities, and cache sizes. For enthusiasts, these numbers mattered. For everyone else, they were meaningless.

Companies like Apple rarely led with specifications. They sold outcomes. Not “5GB of storage” but “1,000 songs in your pocket.” Not “an ARM processor” but “the internet in your pocket.” The underlying technology still mattered enormously. It simply wasn’t the customer’s problem anymore.

AI feels remarkably similar today. We compare models, context windows, benchmark scores, and tokens per second. Enthusiasts will always enjoy those discussions, just as car enthusiasts still tune engines and photographers still shoot in manual mode. But most people don’t want to become experts in model routing. They want to build a website, fix a bug, or write a proposal. The technology shouldn’t be the task.

A prediction

I don’t think model selection is going away. Modern cars still have manual modes and professional cameras still expose every control, so AI products will keep offering advanced settings for people who want them. But they will increasingly fade into the background.

The products that win the next wave of AI adoption won’t have the largest context windows or the most configurable interfaces. They’ll be the ones that consistently make good decisions on behalf of their users. They’ll have earned the right to make those decisions, one good call at a time.

So the next time you’re tempted to add another dropdown, checkbox, or slider to your AI product, ask yourself: is this expressing the user’s intent, or is it exposing my uncertainty?