Saying No Is Engineering Excellence

Imagine you point an AI agent at your GitHub issues. Everyone keeps telling you these things are so smart, so you do the obvious thing and ask it for its opinion: what should we do about the backlog? It scans, finds three separate complaints about laggy search, and comes back with a confident answer: rebuild it on a vector database with semantic embeddings. By the time you finish reading the recommendation, it's already drafting the PR.

Notice what happened. You asked for its opinion. It gave you the most decisive-sounding action. It also skipped the obvious chain: add the missing index, debounce the input, return fewer results per page. The boring fixes that almost certainly close the issue. Instead it jumped to the rebuild and started writing code.

Code generation is cheap, opinion is not

Software engineering is still a very in-demand skill. That hasn't changed because of AI tools. If anything, the demand is sharper. What's changed is which part of the job is the bottleneck.

Generating code is no longer the hard part. An agent can scaffold a feature, write the tests, wire up the migration, and open the PR while you're getting coffee. The expensive thing now is the opinion that decides whether any of that should ship.

Most of engineering used to be: I have a request, I figure out how to build it. The "how" was where the seniority lived. Now the "how" is mostly free. The seniority lives in the question right before that one: should I build this at all?

AI is great at writing code. It will remove code too, if you tell it to. What it's bad at is the question one level up: should any code change here at all? The Elon Musk principle from manufacturing fits: "the best part is no part". Same in software. The best fix is often no fix. AI doesn't think that way by default. Its instinct is to ship.

The default is yes

Here's what I keep noticing about agentic tools: they are biased toward action. Ask one to review your issues and it wants to close them. Ask it to read a complaint thread and it wants to make the complaints go away. That's what they were trained to do: turn a request into work.

So you get the search scenario. Three users have complained that search feels slow. The agent reads the issues, runs an analysis, and proposes a vector-rebuild because that's what the trend says you should do. It drafts a migration plan. It sounds confident about it.

But you have, let's say, 10,000 users. Three of them complained. The agent has no opinion about whether spending the next month, the engineering attention, the tokens, the rollout risk, and every consumer of the search API downstream is worth silencing those three complaints. It just sees three issues and an action that would close them.

That's not a flaw in the agent. That's the job description.

What it actually means to say no

Saying no is not laziness. It's the part where you look at a proposal (yours, your team's, your AI's) and you do the unsexy math. Does this make the system more complex? Is the complexity worth it? What's the ROI? What does it cost me, not just to build, but to own?

Sometimes the right answer is: yes, three people are complaining about speed. I see them. I accept that. The current stack earns more for the business right now than the rebuild would. The complaints are a known cost, and the cost is lower than the alternative.

Sitting on a complaint is its own kind of skill. Doing nothing in the face of pressure to act is harder than acting. The agent never has to do it. You do. "I see this and I'm choosing to leave it for now" is engineering work, even when no code gets written and no ticket gets closed.

That sentence is hard to say. It feels like you're failing the customer. You're not. You're owning the trade-off explicitly instead of pretending it doesn't exist.

The engineers I trust the most are the ones who can articulate exactly what they are choosing not to do, and why. Not "we don't have time." That's avoidance dressed up as priority. I mean: "We are accepting this complaint class because addressing it would cost us X and protect us from Y, and Y is smaller than X right now."

Demos are easy. Products are engineering.

Here's where I keep landing on this. A lot of people are vibe-coding tools right now. Small AI-built apps for their own use. They work. They're impressive. They ship in an afternoon.

Going from that to a real product you ship to customers is a different category of work. The DB choice matters. The architecture matters. The language matters. The functional boundaries matter. Someone has to understand and debug every stage of the thing. Customers eventually find the seams, and when they do, you need to be able to explain what's happening and fix it.

The engineering doesn't disappear when the AI writes the code. It moves. Writing the prompts that produce the right output the first time. Curating the skill files and PRD documents the agent reads before it touches code. Framing the task so the agent can't go in circles. Putting tests around the parts you can't afford to let drift. Prompt engineering is engineering. Context curation is engineering. The output is still code; the leverage moved to the inputs.

If you can't do any of that, you are relying on the AI tool to make the architecture decisions for you, over time, on the fly. That's not impossible. It's just very hard to justify to a customer when something breaks. "The agent will figure it out" is not an answer when revenue is on the line.

So: vibe code creates a lot of code, fast. Getting it past a demo is engineering work, just engineering applied to a new surface. AI writes the code; the mastery shows up in what doesn't get built and in how the inputs are shaped.

The optimization-hell loop

Here's the failure mode I've watched eat real teams. You start with a stack. People complain about something: performance, DX, scaling. You decide to switch the stack to fix it. The new stack is, predictably, worse on the things the old stack was good at. So you spend months pulling the new stack up to where the old one was. Improvement after improvement after improvement. Eventually you're back at "good," roughly where you started but with a year of work behind you.

Then someone complains about the new stack. The cycle restarts.

I call it optimization hell because each individual decision looks rational. The migration was justified. The improvements were justified. The eventual replacement of the new stack will be justified too. But the loop (the meta-pattern of constantly tearing the foundation out from under yourself) is irrational. You never compound. You're always at zero plus a year of catch-up.

Avoiding this loop is a big chunk of what senior engineering actually is. Not picking the perfect stack. Picking one that's good enough and then staying there through the noise.

When AI agents accelerate the loop

Here's the part I've been chewing on. AI tools make the loop faster, and they make a particular variant of it dangerous in a new way.

The friction that used to protect you from constant migrations was that migrations were hard. Someone had to spec it, scope it, build it, test it, roll it out. That friction made you ask, every time, "is this really worth it?" The cost was visible.

Now the cost is partially hidden. An agent can draft the migration plan, generate the schema diff, write the dual-write code, and open the PR overnight. The visible cost (your time) drops. The real cost does not: the complexity it adds, the time you spend owning and debugging the new system, the cutover risk, the regression in things the old system did well. It just becomes invisible until later.

The other variant: agents pick stacks that fit the work, not the team. I worked on a project where the team knew React well, but the AI gravitated toward Vue. Both work. Both are fine. The difference shows up at debugging time.

A button was missing from the frontend. A small bug. The agent took multiple loops and couldn't fix it. We ended up in a five-hour search session. Humans on a codebase the AI had built in a framework the team didn't know cold. We got there in the end. But imagine that same scenario in production. Customer-facing. No human on the team able to navigate the codebase fluently. The debugging tools themselves vibe-coded on the fly. That's not a place I want to be.

If you don't apply the no-filter, AI tools will happily walk your codebase into optimization hell faster than any human team ever could. Matt Pocock makes this point sharply in How To De-Slop A Codebase Ruined By AI: AI hasn't just sped up code generation, it's sped up software entropy. Codebases fall apart faster than they used to. His rescue skill is architecture fundamentals: deep modules, disciplined refactoring. Mine is one rung earlier: don't let the entropy in to begin with. Same fight, different end of the pipe.

What this looks like in practice

A few things I try to actually do, when I notice the pull toward "yes":

  • Treat agent proposals as junior PRs. I don't merge a junior dev's first migration plan because it compiles. I push back, ask why, ask what the alternatives were, ask what we're choosing not to do. Same with an agent.
  • Read complaint ratios as signals, not proofs. Three issues about slow search doesn't mean 9,997 users are happy. It means three were annoyed enough to file. The ratio is a signal to investigate, not a license to ignore. The job is to figure out which it is, then act accordingly, which sometimes still means "do nothing."
  • Write down what we're explicitly not doing. A short doc titled "decisions we declined this quarter and why" turns saying no from a habit into a record you can defend.
  • Pick the boring stack you know and stay there. Cheaper than the cool stack you'd have to learn while running production on it. Exception: the current stack is demonstrably blocking scale, hiring, or revenue. Then move. Otherwise, the boring stack wins by default.

None of this is groundbreaking advice. It's just harder to hold the line when the cost of saying yes keeps dropping.

What's still ours

The skill that used to be "knowing how to build" is shifting toward "knowing when not to." AI agents are doing more and more of the first-draft building now, and they're good at it. They're not yet good at sitting on their hands. They're not yet good at telling a customer why nothing got shipped this sprint.

You can, of course, try to teach an agent how you make those decisions. Codify the heuristics, build a skill file for it, write a PRD that captures the trade-off math. Maybe in a year an agent will say no on your behalf. Anthropic's 2026 agentic-coding trends report calls this kind of evolution "bounded autonomy", where human oversight shifts from reviewing everything to reviewing what matters. But the human role doesn't disappear when that happens. It moves up. Instead of deciding "do we rebuild search?" you're overseeing five agents that are each making that call across five projects, and your job is reviewing those decisions instead of making them. The judgment moves to the next rung of the ladder. It doesn't go away.

That's the part that's still ours. For now, and probably one rung above whatever rung the agents climb onto next.