What If Experienced Developers Are Next?

Why senior developers might be making the same assumptions about their value that travel agents made in 1995

The numbers were stark. A Stanford study released in August showed a 13% decline in employment for young workers aged 22-25 in jobs most exposed to AI. Around the same time, Harvard researchers analyzing LinkedIn data from nearly 285,000 firms found that companies adopting AI had cut junior hiring by 7-12% while leaving senior positions untouched. After months of debate about whether AI was actually affecting employment, we were starting to get data.

Companies weren't just automating tasks; they were replacing an entire category of worker. The bottom rung of the career ladder was disappearing.

I'd written about this possibility back in January, worried about what I called "the end of apprenticeship"—how AI might break the traditional pathway from junior to senior roles that had defined professional development for generations. The concern felt abstract then, more philosophical than practical. How do you become a senior developer if there are no junior developer jobs?

The End of Apprenticeship: What We Lose When AI Becomes the Junior

But as I watched the data come in over the summer, I began to wonder if I'd been thinking too small. There is an assumption that this wave would stop at the bottom rung—that senior developers, with their strategic thinking and business judgment, will remain safe. The prevailing narrative is reassuring: AI would handle the grunt work, freeing up experienced professionals to focus on higher-value activities.

What if we're wrong about where this stops?

What if the wave doesn't pause at the bottom rung but instead takes out the ladder?

This is a thought experiment, not a prediction. There are plenty of reasons why software development might be different, why the complexity of business requirements and architectural decisions will protect experienced developers. But I can't shake the feeling that we've heard these arguments before, in a different industry, from people who were just as certain about their irreplaceable expertise.

The question that keeps nagging at me: What if what we think makes us valuable isn't as valuable as we think?

The Travel Agent Precedent

The assumption that senior workers benefit from automation while adding irreplaceable value isn't unique to software development. We've seen this pattern before, and it didn't end the way the experts expected.

Let's imagine we're at a travel agency back in 1995. A senior travel agent gets a call from a client wanting to plan a two-week European business trip with a family extension. This isn't just booking flights—it's orchestrating a complex dance of logistics, relationships, and expertise.

The agent fires up their SABRE terminal, one of the airline reservation systems that gave them exclusive access to inventory and pricing that consumers couldn't reach. But SABRE is just the starting point. They need to coordinate multiple hotel chains, ground transportation, visa requirements, and a dozen other moving pieces. They know that Frankfurt transfers need at least two hours if you're connecting between terminals. They remember that the Hilton Paris rooms on floors 3-5 haven't been renovated yet, so they'll book floor 6 or higher.

The junior travel agent handles the legwork—running pricing scenarios across different date combinations, calling hotels to check availability, printing out itineraries with all the confirmation numbers. But the senior agent is the one synthesizing everything. They understand that this client values efficiency over luxury, that his wife prefers boutique hotels. They present two carefully curated options, each representing hours of expert judgment about trade-offs the client doesn't even know exist.

This felt irreplaceable because it was genuinely complex work that required real expertise. When the SABRE systems got more sophisticated through the 1980s and early 1990s, it seemed to validate their value. Technology was making them more powerful, not less relevant. They could access more information faster, run more scenarios, provide better service. The junior agents became less necessary as the systems automated more of the grunt work, but their strategic expertise felt more valuable than ever.

By the mid-1980s, 50,000 travel agents were using SABRE alone. The industry was thriving. Senior agents had carved out a clear value proposition: we don't just book travel, we understand travel.

Then came the turn.

It started with clunky airline websites in the mid-1990s where customers could book their own flights. Senior agents weren't worried—the interfaces were terrible, the search was limited, and customers still needed an agent for anything complex. If anything, this validated their expertise. "Look how hard it is for customers to do this themselves," they'd say. "They'll always need us for the real work."

But in 1996, something different emerged. Travelocity launched—ironically, owned by SABRE itself. Then came Expedia. These weren't just giving customers access to the same clunky booking systems. They were building something different: platforms that made the complexity disappear.

The platforms didn't replicate travel agent expertise—they revealed what customers actually valued.

Travel agents thought customers paid for expertise. Knowing that Frankfurt transfers were tight. Remembering which hotel rooms were renovated.

Turns out customers were paying for access to booking systems. The expertise was just the price of admission.

When platforms unbundled these services, customers got direct booking access. Suddenly they could DIY the expertise—seeing connection times on screen, reading hotel reviews from actual guests.

The expertise was still there. Senior agents still knew more about travel than customers ever would.

But customers didn't value it as much as the agents had assumed.

Travel agent employment peaked at 124,000 in 2000, then fell to 74,000 by 2014—a 40% decline in 14 years.

The agents were right about their expertise. They were wrong about its value.

The Software Development Mirror

Now let's turn to software development and ask the same question.

A senior developer today gets called into a meeting about building a customer portal for a mid-size company. This isn't just writing code—it's understanding business requirements, user needs, and system integrations.

The developer fires up their IDE and starts sketching out the architecture, but the real work happens in understanding what the business actually needs. Different customers need different access levels—some see pricing, others don't. The sales team wants leads captured one way, but support tickets need to flow differently. The existing CRM has customer data, but it's organized around sales cycles, not customer self-service.

The junior developer handles the legwork—setting up the database schema, writing API endpoints, building form validation, running tests. But the senior developer is the one synthesizing everything. They understand that enterprise customers expect different functionality than small businesses. They remember that the CEO wants customers to see order history, but accounting says some old orders shouldn't be visible. They know that the support team needs certain customer information flagged immediately—details that came up in passing conversations but could break the entire user experience if missed.

This feels irreplaceable because it's genuinely complex work that requires real expertise. When GitHub Copilot and other coding tools got better through 2023 and 2024, it seemed to validate their value. Technology was making them more powerful, not less relevant. They could write boilerplate faster, debug more efficiently, implement features more quickly. The junior developers became less necessary as the tools automated more of the grunt work, but their strategic expertise felt more valuable than ever.

Today, companies report that AI coding tools are boosting developer productivity by 20-30%. The industry is thriving. Senior developers have carved out a clear value proposition: we don't just write code, we understand business requirements. We know the difference between what stakeholders say they want and what they actually need. We have relationships with product managers who trust our technical judgment. We've been in those meetings. We turn the chaos of business requirements into working software.

But what if we're at the same point senior travel agents were in the mid-1990s?

Right now, we have AI app builders like Lovable and Bolt.new that can generate simple applications from natural language descriptions. Google just launched Firebase Studio, a cloud-based platform powered by Gemini that promises to build full-stack AI apps right in your browser. Senior developers aren't worried—the output is often wrong, the integrations are limited, and businesses still need a developer for anything sophisticated. If anything, this validates their expertise. "Look how hard it is for AI to understand what we actually need to build," they say. "It'll always need us for the real work."

But what if these platforms evolve the way Travelocity and Expedia did?

What if by 2026, Firebase Studio can handle the complexity that currently requires senior developers? What if it can read through two years of Slack messages and meeting notes to understand business context? What if it can parse email threads and documentation to find edge cases? What if it can analyze support tickets and user feedback to design better user experiences than expert judgment provides?

The Uncomfortable Parallel

Senior developers bundle the same two things travel agents did. Access to complex systems plus domain expertise.

Travel agents knew how to use SABRE, which was hard for consumers to access, and they knew how to put together travel itineraries. When platforms unbundled these services, customers were willing to DIY the expertise part. They knew their travel needs well enough.

Software developers know how to build, deploy, and maintain complex software systems, and they have domain expertise about software requirements. If platforms make building and deploying software easy enough, would businesses be willing to DIY the requirements gathering? After all, they know their business needs better than anyone.

The expertise would still be there. Senior developers would still know more about software architecture than their stakeholders ever will.

But would businesses value it as much as developers assume?

Related