TLDR
We’ve moved up the stack before
I keep coming back to one idea: we (developers) are moving up the abstraction stack...again.
First we wrote raw code. Then we designed systems. Then we managed teams. Now something new is forming - agent swarms.
I do feel like this is all pretty sudden, but it’s actually the same pattern repeating. We don’t remove humans from the process, we just move them up a level.
What matters: this isn’t necessarily a break from history but more so the next step in the same direction we’ve always gone.
Code is becoming the implementation detail
CJ Hess said it best in his viral Twitter post: soon the main skill won’t be writing code or even architecting systems. It will be defining problems clearly enough that an agent swarm can solve them.
I really like his post.
Refactoring, testing, wiring services together, debugging edge cases. All of that still matters. Like really - it does matter a lot. But it’s no longer where the leverage is. What I mean by this is: two developers can use the same swarm and get wildly different results. Not because one writes better code, but because one defines the problem better. The quality of the output starts to mirror the quality of the input.
What matters: the bottleneck is shifting from “how do I build this?” to “what exactly should be built?”
Orchestration becomes the real craft
I think the overall sentiment now for when people hear “agents” is that they think automation. Click on a button and few actions happen. (I would argue this is not what agents or agentic systems are)
That’s surface level.
The real skill that will be in high demand is coordination. Being able to break messy ideas into clean tasks. Defining any dependencies, making goals measurable and definitely making “done” unambiguous for the current implementation/iteration.
The new elite skill is not typing faster. It’s being at that intersection of coordinating agents/swarms and working with the stakeholders/owners.
A new middle layer will emerge
Generally speaking, I do think most people are bad at defining problems. By no means am I calling anyone dumb or incompetent. Just messy in how they explain topics, irrational explanations of events within a story, making the takeaway more difficult than necessary, etc.
"They" may say things like “make it faster” or “fix onboarding” or “improve auth.” All of this is fluff, fog, and not what these systems need. In my experience, agents and especially swarms need structure.
So a new layer will form between human intent and technical execution. People who translate vague goals into precise instructions that machines can actually act on. A specialized type of developer to optimize user input to produce the best possible output from these systems.
The “killer developer” changes
One can make the argument that the best developers used to be the ones who deeply knew a language or frameworks or had the most experience (I agree and disagree w/ this - probably worth a different blog post).
Soon, the next few years, it will be the ones who can shape problems perfectly. Who can see hidden dependencies. Who can define success in a way machines can execute.
Currently, we're only at the second layer. The third layer is coming. It will be less about managing tasks and more about directing and orchestrating the swarm for optimal outputs.