hands on the cables
in the early days of aviation, pilots flew by feel. they had their hands directly on the cables, their feet on the specialized pedals, mechanically pulling and pushing to move the rudder and ailerons. the connection between intention and action was physical, immediate, and demanding.
software development followed a similar trajectory. we used to write every line of code by hand, manually configuring servers, and stitching together disparate systems. it was a one-developer-one-module scope. then came version control, better tooling, and open source, which allowed us to operate at a higher level of abstraction and manage larger scopes. but despite these advancements, the work remained largely manual—hands on the keyboard, mind on the syntax.
just as modern aircraft moved to fly-by-wire systems—where the pilot’s input is an intent translated into action by a computer—we are now seeing a shift where our intent (the “vibe”) is translated into code by ai. we are no longer pulling the cables; we are setting the course.
autopilot and copilots
then came the autopilots—systems that could hold altitude, follow waypoints, and even land the plane in zero visibility. they didn’t replace the pilot, but they fundamentally changed the job. the pilot became a system manager, monitoring instruments rather than constantly making micro-adjustments to the controls.
in our field, we’ve moved from discussion forums like stackoverflow being our primary source of assistance to having ai agents live in our editor. tools like cursor act as our copilots, handling the mundane implementation details. we state the problem, and the agent writes the boilerplate, refactors the functions, and suggests the tests. we are transitioning from writing code to reviewing it, from implementation to oversight. the manual dexterity of typing out syntax is becoming less valuable than the judgment required to verify the output.
compression of roles
commercial flights used to require a navigator to chart the course, a flight engineer to monitor the engines and fuel systems, and a radio operator to handle communications. as technology improved, these roles were absorbed into the cockpit’s avionics. the navigator became a gps system; the flight engineer became an engine monitoring display. the distinct roles vanished, but the responsibilities remained—now consolidated onto the two pilots in the front seats.
software development is undergoing a similar compression. the role of the dedicated qa engineer, the database administrator, the frontend specialist, and the backend engineer are blurring. with ai assistance, a single developer can confidently traverse the entire stack. a frontend developer can scaffold a backend service; a backend engineer can generate a react component. the scope of what a single individual can build and maintain has expanded dramatically. many developers are becoming more full-stack captains, capable of managing a flight that used to require a crew of five.
illusion of redundancy
with so much automation, it’s easy to fall into the trap of thinking the human is redundant. if the plane can fly itself, why do we need two highly paid pilots up front? if the ai can write the code, why do we need senior engineers?
this is the illusion of redundancy. the pilot isn’t there for when things go right; they are there for when things go wrong. they are there to understand why the plane is doing what it’s doing, not just to watch it happen. similarly, an ai can generate a working function, but it doesn’t understand the broader architectural implications, the security constraints, or the business logic in the same way a human does. the code it generates is a suggestion, not a truth. without a deep understanding of the “physics” of our software—memory management, concurrency, distributed systems—we are passengers in our own codebases, not captains.
when engines fail
the true value of the captain is revealed in the edge cases. when an engine fails at 30,000 feet, the autopilot disengages, and the human must take control. when the production database locks up during a black friday sale, or a security vulnerability is exploited in real-time, the ai agent can’t save you. it can’t reason about the trade-offs between data consistency and availability under extreme duress.
in these high-stakes moments, you need a human in the loop who understands the system deeply. you need someone who can “hand fly” the application when the automation fails. the future of software engineering isn’t about writing boilerplate; it’s about being the person who knows what to do when the boilerplate breaks.
captain’s future
we are not in a bubble that is about to burst; we are in a transition that is irreversible. the optimistic view is a massive boost in productivity—larger systems built by smaller teams, deeper research, and more ambitious projects. the pessimistic view is the erosion of junior roles, the roles that used to be the training ground for future captains.
but the need for the captain remains. we are moving away from the era of syntax-focused development and into the era of the software pilot. the job definition is changing from “typing code” to “designing and managing systems.” to stay relevant, we must embrace this shift. we must learn to use these new copilots effectively, but never forget how to fly the plane ourselves. the moment we lose the ability to understand the underlying mechanics is the moment we become passengers. and passengers don’t get to steer.