A partner I work with told me recently that when he delivers code to a client, he can give them a line-by-line walkthrough of everything that was built. He said it with pride.

Eighteen months ago, I would have heard that as a sign of professionalism. Of ownership, of taking the work seriously, of treating the client's codebase like his own. Today I hear something different. I hear a productivity ceiling.

Because the volume of code being shipped has gone up by an order of magnitude, but the human bandwidth to read code line by line hasn't moved at all. If you insist on personally understanding every line that ships, you've capped your throughput at human reading speed, which is now the slow lane. You're not being more rigorous than your competitors. You're just slower.

In my last piece, I argued that AI rewards agency, not skill, and that's what's reshaping who climbs the top arm of the K. This week is about what happens when that reshaping hits the rest of the team, including the parts that are hard to say out loud.

I've had to let go of people with low agency and weak critical thinking. Not because they were bad people. Not because they couldn't code. They could.

The reason is harder to say: in an AI-amplified environment, low-agency contributors don't just produce less. They slow down everyone around them. One person waiting to be told exactly what to do generates rework for two people who had to figure out what should have been figured out without supervision. The cost compounds. A team of eight with two low-agency devs doesn't perform like a team of six. It performs worse than a team of six, because the friction the two add is greater than their output.

The empathetic read most managers won't articulate: it's not that the bottom arm is lazy, or untalented, or not trying. The job has structurally changed underneath them. The new job rewards traits that some people genuinely don't have, and may not be able to develop quickly enough to matter. Holding onto them is kind in the short term and cruel in the long term. Cruel to them, because they're being asked to compete in a game they can't win as currently constituted. Cruel to the team, because their friction is real. Cruel to the business, because the gap between teams that have made the shift is widening every quarter.

The hardest cases aren't the people who can't adapt. They're the people who won't. Some of the most experienced engineers I know are bottom-arm right now, and it's not because they lack the skill. It's because their identity is wrapped up in a definition of craft that no longer pays.

Which brings me back to the partner with the line-by-line walkthrough.

The answer isn't to give up on understanding code. The answer is to change what the code is optimized for.

Matt Pocock made this point well at a recent AI Engineer talk (worth watching). His argument: software fundamentals matter more than ever in the AI era, but the fundamentals are now in service of a different reader. Code used to be optimized to be read and modified by humans. The right move now is to optimize code to be traversed and modified by LLMs.

Concretely:

This is destabilizing for people whose identity is built on the old craft signals. The line-by-line walkthrough. The pristine 50-line file. The perfectly factored abstraction. The elegant generic. Those signals don't translate. The new craft signals are different. Code an agent can navigate, prompts an agent can act on, specs an agent can hold in context. They feel less satisfying because they don't look like mastery the way the old ones did. There's no obvious place to admire your own taste.

But they're what works. And the people who are figuring this out are pulling further away from the people who aren't, every week.

Three things follow.

Hiring has to change, and most processes haven't. Most interview loops still test for the things AI now does. They don't test for agency, for cross-boundary thinking, or for the willingness to start without a clear path. The signal-to-noise ratio of a traditional coding interview has gotten worse, not better. You can pass it with AI assistance, but passing it tells you almost nothing about whether someone will be top-arm or bottom-arm on a real team.

Promotion ladders have to change, and most haven't either. Most career ladders still reward depth in a specialization. The people who deserve to climb fastest right now are often the ones whose contributions are hardest to slot into the existing ladder. The generalist who can swap stacks. The engineer who can think like a PM. The dev who shipped something the team didn't know was possible.

Becoming top-arm yourself is harder than either of the above. It requires giving up signals of professionalism you may have spent a decade building. The pristine code review. The deep specialization. The line-by-line ownership. None of those are wrong, exactly. They're just no longer where the leverage is. And it's much easier to update a hiring rubric than to update your sense of what good work looks like.

Agency is what lets individuals cross to the top arm of the K. Updating your sense of craft is what keeps them there. Most of the gap inside teams right now isn't a tooling gap or a training gap. It's a willingness gap. A willingness to act without permission. To redefine craft mid-career. To let go of people who can't or won't make the same shift.

This is the part of the AI transition that most of the discourse skips over, because it's not optimistic and it's not solvable with a SaaS purchase. But it's the part that determines whether your team is one of the ones pulling away or one of the ones falling behind.

Next week, the third piece in this series. Agency is what lets individuals cross. But there's a parallel thing happening at the level of companies. Moats are collapsing, building has never been cheaper, distribution has never been harder. The implications for small software firms are uncomfortable, and most of the industry hasn't reckoned with them yet.

Experiencing something similar in the team you’re working with? Hit reply.
I want to hear how you're building and what it is that you’re seeing.

Karan Shah
Founder & CEO, SoluteLabs
Building AI-native products before it became cool.