My teenage son plays the cello. He has played it solo, as part of a small chamber Orchestra and as part of a larger Orchestra. The more and more I think about the future of technology, the more convinced I am that this analogy captures exactly where we're headed.
For decades, engineering has been structured around individuals writing code, debugging systems, and operating infrastructure directly. But that model is already changing; and it’s going to change even faster in the coming years.
In my view, the best analogy for the future of engineering is that of an orchestra.
Today, engineers often act as both musicians and conductors: writing the code, deploying the systems, debugging the failures, and coordinating the work. But increasingly, the musicians will be agents. The engineers who thrive will be the ones who become conductors.
The Orchestra of Agents
Think about an orchestra.
Each musician is highly specialized. The violinist doesn’t suddenly pick up the trombone. The percussionist isn’t improvising the cello part. Every instrument plays a specific role, with focused expertise.
That’s exactly what agents are good at. Agents excel when the work is focused, specialized, rule-driven, and technically deep. In other words, the kinds of tasks that engineers currently spend much of their time doing: such as writing implementation code, refactoring modules, generating tests, running migrations, reviewing logs, producing documentation, writing infrastructure configs.
These are the individual instruments of software development. Agents are becoming very good at playing them.
But there’s a fundamental truth about orchestras: You cannot run an orchestra by letting the second viola decide what happens next.
Enter the Maestro
Even if every instrument is played perfectly, an orchestra without a conductor quickly falls apart. The conductor’s job is not to play the instruments. Their job is to ensure the correct notes are played, the timing is right, the volume and balance are correct, the instruments enter and exit at the right moment and that no single section overpowers the others. Every instrument enters and exists at exactly the right moment because someone is watching.
The conductor is responsible for the composition as a whole. In my view this is exactly the role engineers will increasingly play. Agents may generate the code, run the analysis, and perform the implementation; but someone must ensure the system remains coherent, safe, and aligned with the intended design.
That someone is the engineer.
The Amazon Example: When the Orchestra Breaks Down
This dynamic became visible just this week in an example from Amazon, where production outages were linked to problematic code changes. This is not a one-off. This is a preview of what we’re about to see more frequently as AI-driven development accelerates.
Historically:
- Junior engineers implemented features
- Mid-level engineers expanded systems
- Senior engineers reviewed and guided architecture
In the agent-driven world:
- Junior and mid-level engineering tasks become agents
- Code generation accelerates dramatically
- Changes happen faster than ever
But speed without oversight is how things break. If code is being produced at machine velocity, review and orchestration become the critical bottleneck. And right now, most organizations are not set up for that. Senior engineers now face a new responsibility: reviewing AI-generated work and ensuring it integrates safely into production systems.
In our orchestra analogy:
- The instruments are the agents writing code.
- The score is the system architecture.
- The conductor is the senior engineer ensuring the performance holds together.
Engineers as conductors
The most valuable engineers in the very near future will not necessarily be the fastest coders. They will be the engineers who can:
- Design clear architectures
- Coordinate multiple agents and systems
- Validate generated outputs
- Maintain system coherence
- Identify subtle failure modes
- Ensure reliability and safety
They will pull together all the musical threads into a coherent performance. Their job will be less about writing individual lines of code and more about ensuring the entire system behaves correctly. This is a shift from implementation to orchestration.
The Skills That Will Matter
As engineers become conductors, the required skills shift accordingly. The future engineer needs:
- Systems thinking – Understanding how components interact across the entire architecture.
- Judgment – Knowing when generated solutions are correct, risky, or incomplete.
- Taste – Recognizing elegant solutions versus fragile ones.
- Communication with agents – Designing prompts, workflows, and constraints that guide agent behavior.
- Failure analysis – Understanding how complex systems break and how to prevent it.
The conductor doesn’t just wave the baton. They interpret the score, guide the musicians, and shape the final performance.
The Beautiful Outcome
When orchestras work well, something remarkable happens. The individual instruments disappear into the composition. What remains is the music.
That’s the future of engineering systems. Agents will perform many of the individual technical tasks. But the engineer, the conductor, will ensure that everything works together in harmony. The end result isn’t just functioning software. It’s a coherent, cohesive and, dare I say it, beautiful system.
And as in music, the responsibility for that performance will always belong to the conductor.
