Teaching Taste: The New Job of the Engineering Manager

Most engineering managers got the job the same way: they were the best senior on the team, somebody left, and the title landed on them. They learned to manage by doing it. Some of them are exceptional at it — the ones who figured out, through some combination of instinct, luck, and the occasional mentor, that the job they got was a different job than the one they were promoted from. The rest got by on technical credibility and the fact that the team mostly trained itself.

The team trained itself through code review. Through pair programming. Through the daily ritual of watching the most senior person on the team debug something hard. Apprenticeship was distributed, ambient, and free. The manager didn't have to teach much because the team was teaching itself, fifty small moments a day.

That deal expired sometime in the last eighteen months, and nobody told the managers.

What the Team Used to Do for Itself

The team isn't training itself anymore. Not the way it used to.

Code review became a rubber stamp on a diff the AI wrote. The reviewer skims, sees the tests pass, sees the description (also written by the AI), drops a thumbs-up. The teaching moment that used to happen in review — here's why I'd structure this differently, here's the failure mode you didn't see, here's why this is going to bite us in six months — got compressed into an emoji.

Pairing evaporated when the AI became the pair. Why pair with another human — slow, expensive, available thirty hours a week — when you can pair with something that's always on, never tired, never asks you to repeat yourself? The economics of human pairing didn't survive the comparison. Even when the learning value of human pairing remained enormous.

And the junior doesn't watch the senior debug anymore. They have a question, they ask Claude, they get an answer in eleven seconds, they ship. The conversation that used to start with "hey, how would you think about this?" doesn't start. The senior is left wondering why nobody asks them anything, and quietly assumes it's because the team has gotten more capable.

Three things died at once: the place taste got transmitted (review), the place it got demonstrated (pairing), and the moment it got requested (asking). That's the apprenticeship pipeline. It's not broken in some abstract way. It's broken in three specific places.

Taste Is What Didn't Get Automated

AI is extraordinarily good at producing code that follows patterns. It has seen everything. It can give you the standard answer, fast, to almost any question. That's a real capability, and pretending it isn't is silly.

But there's a thing AI can't do, and that thing matters more than ever now that AI can do so much of the rest.

That thing is taste.

Taste is knowing when a clean diff is wrong. When a passing test means nothing. When "it works" is a trap. When the standard answer isn't the right answer here. Taste is the judgment that sits one level above the pattern-matching — it's the ability to look at code that should be right and feel, before you can articulate why, that something is off.

The distinction matters:

• Patterns are "this is how you do X."
• Taste is "X is what you do here. Y looks similar but is what you do over there. Z compiles and passes the tests, but reject it anyway, because it makes the next change harder than it needs to be."

Taste is meta-pattern matching. It's knowing when the pattern doesn't apply. And it is acquired exactly one way: through high-bandwidth contact with someone who has it. By watching them work. By getting your work corrected by them. By having them point at a thing on your screen and explain — sometimes with a sigh — why it offends them.

AI can transmit patterns at infinite scale. It cannot transmit when to break them. It will confidently apply a pattern that doesn't fit, because fit is the exact judgment it doesn't have.

The Job Inverted

The old engineering manager job had a top half and a bottom half. The top half was technical orchestration: triage, unblocking, being the most senior reviewer on every important PR, holding the architectural line. The bottom half was developing the team: 1:1s, coaching, growing juniors into seniors, building the bench.

For two decades, the unspoken trade was: nail the top half, and the bottom half mostly happens by osmosis. The team learns from the work itself, from each other, from the rituals around the work. The manager's job on the people side was to not get in the way and to surface the occasional growth opportunity.

That trade was load-bearing on the team training itself. It doesn't anymore.

The accountability shifted, even if the calendar didn't. If you were promoted to manager in 2019, your job in 2026 is not the job you were promoted into. The strongest managers — and there are more strong ones than the AI discourse gives credit for — sensed this on their own and quietly retooled. They have a list, in their head or on paper, of every direct report and the specific thing they're trying to develop in them this quarter. They know what their juniors don't know. They have a plan for the bench.

The rest are doing the old job harder, working longer hours to do it, and noticing the team isn't getting any deeper. That's not a character failing. That's what happens when the job changes under your feet and nobody calls it out.

Why Is Coaching So Hard for Engineering Managers Right Now?

Coaching is hard right now because three supports went missing at once: no training, no signal, and no time. The honest reason coaching is uneven across engineering orgs is not that managers don't care. The vast majority care a lot. The job just got harder in three specific ways.

No training. Most engineering managers were never taught to coach. They learned management as a side-effect of doing it. That was workable when the job was 70% technical orchestration and 30% people work — the technical part was the part they knew. Now the ratio is closer to inverted, and the gap shows in the part that didn't get any new training.

No signal. Coaching without signal is vibes. You praise the last thing you saw, criticize the last thing that annoyed you, and call it a 1:1. Strong managers compensate by paying very close attention — but very close attention only scales to about five reports. Past five, the manager who can't see patterns ends up coaching everyone the same.

No time. The delivery demands didn't go away. The same OKRs, the same standups, the same pressure to ship. Coaching got added to the job description; nothing came off. The predictable result is that coaching becomes the thing that slides when sprint goals are at risk — which is most sprints.

The first is a training problem. The third is a prioritization conversation between the manager and their manager about what the job is now. The middle one — signal — is the one most teams are quietly blind to. You can't coach what you can't see. And what you used to see — the daily stream of reviews, pairs, and conversations — got compressed into PRs that all look fine because the AI made them look fine.

What Does Coaching With Data Look Like?

Coaching with data has four properties: specific over general, pattern over moment, private over public, and continuous over annual. None of them are exotic. They're just hard to do without infrastructure to back them up.

The infrastructure isn't the point. It's the substrate. The point is the conversation — the correction, the encouragement, the careful transmission of taste from someone who has it to someone who's earning it.

But you can't have that conversation if you walked into the 1:1 without one specific thing to talk about. And you don't get specific things to talk about by accident anymore, because the channels that used to surface them got automated or compressed away.

Where We Fit

This is the gap we built Simyl for. Not to replace coaching — coaching is the human work that defines the job now, and tooling that pretends otherwise is part of the problem. We built it to make coaching tractable by giving the manager something to coach with.

The six dimensions of effectiveness (delivery, flow, quality, collaboration, ownership, adaptability), plus team-level dynamics, give a manager a way to see how each report is growing — not as a score, but as a pattern. The private coaching notes accumulate per-developer across retros, visible only to the manager, until they decide a note is ready to share. The retro itself surfaces team-level signals about who's contributing, who's hanging back, who's quietly carrying the team.

None of that does the coaching. It gives the manager substrate to coach intentionally instead of from memory.

Grooming the Next Flock

The accountability has shifted, whether the org chart says so or not. The manager job isn't gone. It got more important. The part everyone could skate on — the team mostly trains itself — went away. The part that nobody was explicitly trained for — developing the next generation of engineers — became the whole job.

Strong managers already sense this. They've been quietly retooling for two years. They don't need to be sold on coaching; they need to be given a fighting chance to do it well — better training, real signal, and an honest conversation with their own leadership about what's actually expected of them now.

The rest can still get there. The job changed under their feet — it's not a personal failing that they were promoted into one job and woke up in another. But somebody has to teach taste, because taste is the thing AI can't transmit. And somebody has to be accountable for grooming the next flock, because if you blink the bench is empty and the seniors you have today are quietly looking for the next thing.

That somebody is the manager. That's the job now.