Big is the new small
The ramifications of scaling up coding via agents are pretty interesting.
I do think individual coders can attain massive increases in output of greenfield product work agentically. A single dev can manage, let's say, 5-10 agentic crews working 24 hours a day in separate areas of a codebase. This makes a single engineer into a leader of ~25-50 coders, with output increases to match.
Any experienced dev reading the previous paragraph will point out that this creates an orchestration nightmare -- a single person coordinating the work of 25-50 devs who work at different times and can't possibly know what all the others are doing, is a recipe for disaster.
(It's true.)
And then imagine an org of, say, 25 engineers, each of whom starts working agentically. At 25 engineers, you've got three teams, each team's lead can coordinate with the others, that's not a big deal. At 25 engineers working 50 coders each, that's 1,250 coders to coordinate, which is a completely different type of problem.
The fun thing is, this problem has known solutions -- because there are plenty of engineering organizations with a thousand devs. There's even at least a handful of companies with ~10,000 devs. I've worked at 3 of them, and it's interesting seeing the processes there suddenly become relevant for teams that number in the teens.
Big tech companies have whole groups dedicated to the problem of: how do we get engineers the documentation and information they need, narrowly scoped to exactly what they're working on, at the time they need it, with minimal effort required by the engineer.
Of course you will recognize this as the exact challenge agentic systems face: help LLMs to work well without drowning them in cognitive overload, by surfacing only the context/tools/skills they need, at the moment they are materialized.
And there's all these systems to do this. Mostly it's a paper trail that looks like bureaucracy run amok: architecture documents, decision records, runbooks, everything versioned and logged and kept up to date. And these are the tools preferred by the LLMs when you start building software with them, which makes sense since they of course trained their systems from human ones.
What I've found from playing around with these, is that it works really well. It's so important in agentic development to keep the robots on track, and nothing does a better job than a mountain of documentation. Of course, the robots also write the docs and maintain the docs (which, to be honest, they do a much better job at than people do). They don't mind that job and I think it's important to make sure they do it. Just as with people, when the project has hundreds of thousands or millions of lines of code, it's sure nice to have all the old decisions and obscure architecture documented, when a significant change is needed or some unexpected outcome happens.