Taste Still Matters
AI is a force multiplier. It multiplies everything - including the bad stuff.
If you’ve been leaning on AI coding tools, you’ve probably noticed that the generated code tends to look a lot like your existing code. That’s not a coincidence. These models pattern-match against your codebase. If it’s clean and well-structured, AI output tends to slot in reasonably well. If it’s a years-old haunted mansion of copy-pasted logic and functions that do seventeen things at once — congratulations, you now have a very fast haunted mansion generator.
This is why software design, architecture, and good engineering discipline matter more in the AI era, not less. Readable code, testable modules, sensible abstractions — these aren’t just hygiene anymore. They’re load-bearing walls. AI will keep building on top of them, whether they can hold the weight or not.
Taste
When I say taste, I mean the accumulated judgment that comes from having personally broken things and lived with the consequences. Experienced engineers have battle scars. They skipped tests because they were in a hurry and paid for it in a production incident. They built something that wasn't modular enough and had to rewrite half the system when the business requirements changed. They operated a service through a traffic spike and learned — viscerally, at 2am — exactly where the seams were.
Those experiences load something into a senior engineer’s brain that I can only describe as a latent roadmap. It’s not written down anywhere. It’s a slow-burning awareness that runs quietly in the background. They’re implementing a feature and somewhere in the back of their mind a voice goes: “this data model is going to hurt us when we need multi-tenancy” or “we’re going to regret this tight coupling.” It’s there, running — and it wakes up at exactly the right moment, when a decision is about to get made that’s going to have consequences eighteen months from now. They also know when not to act on it. They can see the right long-term solution and still choose to defer it, because right now the business needs to ship. That’s years of calibration compressed into a gut feeling.
Let me give you a personal example. At one company I worked at, we had business logic hardcoded across web and mobile that should have been driven by a backend API. The team had been living with it for a while and nobody flagged it as a problem. To them, it was just how it worked. When I came in, something felt off immediately — built from years of seeing what happens when business logic lives in the client. One change in one place, reflected everywhere. Simple fix, but nobody saw it as a problem that needed solving. Had I not stepped in, the AI assistant would have kept right on hardcoding that business logic — efficiently, consistently, confidently — every time a ticket came in. It was doing exactly what it was asked to do. The problem is nobody was asking the right question.
That’s the crux of it. Junior engineers don’t know they’re perpetuating a bad pattern because from where they’re standing, there is no bad pattern. The problem is invisible to them — and AI has no way to surface it, because it’s pattern-matching against the same codebase they’re looking at.
AI-native engineers, through no fault of their own, simply haven’t had the time to load that latent roadmap yet. This matters more now because AI removes the natural friction that used to slow bad decisions down. A problematic abstraction can now be replicated across a codebase in an afternoon. Tech debt doesn’t just accumulate — it compounds, silently, until refactoring isn’t a sprint task anymore but a quarter-long initiative that requires everyone to stop shipping and fix the foundation.
What Do You Do?
Get the latent roadmap out of people’s heads. Encourage senior engineers to name it out loud — in planning, in design reviews, in passing. “Heads up, this is the kind of decision that tends to bite us in eighteen months.” Over time, junior engineers absorb the reasoning, not just the rule — which is how they eventually build their own version of it.
Pair the people who have the scars with the people who are fast, as I’ve written about in The New Power Duo of Pair Programming. AI-native engineers bring speed and tool fluency. Experienced engineers bring the latent roadmap and pattern recognition. The pairing isn’t about supervision — it’s about cross-pollination.
AI isn’t going anywhere. The teams that get the most out of it are the ones who pair it with strong engineering culture, not the ones who use it as a substitute for one.
Taste still matters. Maybe now more than ever.
As always, ship it.
Matthew
At what point in your career did you start smelling problems rather than just seeing them? How do you actively develop taste in your junior engineers? Let’s discuss in the comments below.