eccher.
PT
Leadership

Whoever signs off on what they haven't read approves what they've heard.

· · 10 min read
Translated from Portuguese. Read the original

The technical leader who has drifted away from the code keeps approving what the team ships and weighing in on architecture, and the executives still go to that leader with questions about deadlines. What changes is the raw material behind those decisions. At some point, with no warning, the leader may start judging mostly the team's explanation of the work, because the work itself is no longer legible to them. If the explanation sounds coherent, with the technical terms in the right places and a deadline that works, they risk signing off on the work.

I call this management by report. It works as long as the report is good, but as I see it, the people who practice it find it harder and harder to tell when the report has stopped being good.

My position is that every technical leader needs to stay close to the code as often as their position calls for. How often varies a lot from one role to another, but it never reaches zero, because at zero, management by report becomes the only way to operate. AI writing code changed this math in two directions at once: it made relying on the report riskier, and it shortened the way back for people who drifted away.

I spent six years away without noticing

I was away from the code from 2020 to 2026. At first I didn't notice, and there was a reason for that: I was leading systems implementation teams and, later, delivery teams, roles that didn't require me to be hands-on with the code. The job called for something else (schedules, people, a sense of how much a team can take before it breaks). I delivered that, and nothing in my day-to-day work made the distance apparent. It only showed up when I took on a technology leadership role, and at that point it was clear I had to catch up.

Today I understand how things work, I suggest directions, I research ideas, and I contribute hands-on to the operational work, up to a point. I don't yet review code as deeply as I want to, and I'm working my way back. For the deepest technical work, I rely on the team's go-to technical people, and that reliance is exactly where management by report catches up with me: when the analysis depends on carefully reading what was written, I depend on whoever read it.

I make up for it with the experience I have. I know how to organize a project and work with people, and I can read the pace a team can sustain well enough to tell an achievable goal from one that's only a wish. That protects the operation and keeps me from promising the executives something the team can't deliver, which already counts for a lot. The limit is that this experience measures the team's capacity and doesn't replace a technical assessment of the code.

How often leaders need to be in the code depends on the seat they occupy

James Stanier settles an old confusion in one sentence: "All managers should be in the code, but not all managers should be writing code." His distinction separates being in the code from writing it. One way to be in the code is to read it: understanding the structure, following the decisions the team made, noticing when something departs from the standard. He also counts things like pairing with the team as being in the code; they bring a person closer to the work without making them its author. How often that presence happens depends on where the person sits.

In the split I propose, which varies from organization to organization, the tech lead writes and reads code all the time. The engineering manager only needs to read enough to check the team's report against something concrete, and anyone above that level goes down into the detail from time to time, in areas they pick, and then comes back up. Christopher Payne, former president and COO of DoorDash, describes that last seat as requiring the ability to go down into the detail and then generalize; without it, he says, an executive loses the ability to have real impact. Payne is speaking from operations, and I think the same principle holds for engineering, because looking at the detail is what keeps the generalization in line with what actually happens.

This is urgent because the distance grows on its own. Charity Majors, co-founder of Honeycomb, wrote that a manager's engineering skills and context decay the longer they stay in the role, and that the best frontline managers are never more than two or three years removed from hands-on work. It's a practitioner's opinion with no data behind it, and I accept it because it describes precisely what I went through. My time away was much longer than the two or three years she mentions, and the decay gave no warning at any point along the way.

The distance also costs the people being led. In a study published in the ILR Review in 2017, Artz, Goodall, and Oswald found that a boss's technical competence was the single strongest predictor of job satisfaction, and that when that competence improves, the well-being of workers who stay in the same job and workplace rises along with it. The finding is a correlation, based on samples of young workers in the United States and of workers in the United Kingdom, and it measures satisfaction; it doesn't support saying that one causes the other. Even with those limits, I think it adds something the debate about managers and code usually leaves out: the technical competence of the person leading goes hand in hand with how people feel at work.

My bet on AI and the report

My bet is that AI writing code increases the need for a solid structure for validation and quality management, because more code is going to arrive for review, and faster, while the confidence with which a solution is presented says little about whether it's correct. The second bet goes further: a team that hasn't mastered good practices for using AI tends to become hostage to the tool and lose control of what it ships.

Put the two together and the scenario that worries me is a leader running on management by report who receives an explanation from a team that is itself trusting the tool's explanation, which adds up to a report of the report. Each layer seems reasonable and confidently explains what it got from the layer below, and nobody in the chain has read what was written closely enough to sign off on it. If my bets are right, the distant leader becomes the point in the chain where the problem arrives without being recognized.

The same technology shortened my way back, and coming back now is different from what it once was. In my case, AI helps me study and greatly shortens the time between not understanding something and understanding it. It even helps steer my analysis when I need to decide where to look first. The way I found to study was through personal projects alongside my job, and those projects are where I get the knowledge I bring to my day-to-day work. For me, that changed the calculation, because the cost of coming back dropped, and I believe the same holds for others who drifted away.

The strongest objection comes from people who lead at scale

The most serious objection to all this comes from Jeanne DeWitt Grosser, COO of Vercel. Talking about business, product reviews, and operations, she argues that from the second level of management up, a leader can't be in every review and has to design systems that make decisions without them. In the Harvard Business Review, David Garvin quoted Eric Clayberg, an engineering manager at Google: "Engineers hate being micromanaged on the technical side but love being closely managed on the career side." The strongest version of the argument I can build from the two says that a manager's closeness to the code tends to turn into micromanagement and a bottleneck, and that a leader's value lies in systems and people.

I agree with half of that, and it's a big half. Applying Grosser's reasoning to engineering is my own analogy. To me, the ideal is for Staff and Principal engineers to own standardization and quality in the team's work; they're the ones who should be in the code reviews that matter, setting the standard and holding people to it. Seen that way, a second-level leader who tries to fill that role becomes a bottleneck. That conclusion is mine, drawn from what she says about scale.

Where I disagree is the leap from "close to the code" to "micromanager." As I understand it, micromanagement is a way of deciding: taking from the team a decision that belongs to the team. Being close to the code doesn't necessarily mean doing that. Knowing the code well enough to understand what the team decided is what gives a leader some grounds for trusting that decision. Clayberg condemns technical micromanagement, and I treat following the code to understand what you're approving as a separate activity. Grosser herself goes deep in some areas, which shows that her argument calls for choosing where to go deep, and choosing assumes that going deep is still part of the leader's repertoire. In its research on effective managers, published on re:Work, Google listed "Have key technical skills" among its ten behaviors, on the same list as "Empower the team without micromanaging," and it expects to find both in the same manager.

What I'm arguing for is a balance in which Staff and Principal engineers uphold the standard and everyone, from the tech lead up to the executive level, stays close to the code as often as the seat they occupy calls for, enough that the report can be checked. The trust a team places in its leader goes well beyond code. It comes from understanding what the team does, giving direction with sound judgment, and reaching goals together with the team. Code is one part of that trust, and it's the part management by report can wear away first, without anyone noticing.

I don't have an exact measure of how much each seat requires at each company, and that call belongs to whoever knows their own team. What six years away taught me is that the distance from the code set in while I was busy with work that genuinely called for something else, and in my case it only showed up when I moved into a different seat. My return is still underway, still short on depth in code review, and sped up by the same AI that, as I see it, raised this risk. I've chosen the direction, because the alternative is to keep approving what the team ships based on what I'm told about it, and that is exactly the management by report I'm trying to leave behind.