The Democratization of Software Development

For most of us, I think the picture is obvious. The job we did for years, picking up a ticket, opening Figma, digging through the codebase, typing code into a file, adding a test, debugging the test, jumping to Stack Overflow, getting in the zone, and grinding on a single task for hours, those days are ending.

Everything that took us so long to get good at, learning the language, memorizing shortcuts, understanding Git, all of it, can now slowly be handed off to agents.

It’s the same reason we don’t write assembly anymore. Before long, we won’t write Vue or React or Java by handIn Five Years, Developers Won't Write Code By HandSoftware development as translation work is dying. Software engineering—the strategic, architectural discipline—is more valuable than ever. The shift is already here.aisoftware-engineeringJan 14, 2026 either.

And it’s already happening in another way. We’re starting to stop reading the code. We just check whether the behavior we wanted actually works.

The team that used to be#

For years, getting an idea from a customer’s head into a shipped product meant passing it down a chain of people. The customer talked to a PM, the PM wrote it up for a designer, the designer handed mockups to a developer, and the developer turned it into code. Every arrow was a handoff, and every handoff was a place where meaning got lost.

   +------------+
   |  Customer  |
   +-----+------+
         |  "I need X"
         v
   +------------+
   |     PM     |
   +-----+------+
         |  ticket
         v
   +------------+
   |  Designer  |
   +-----+------+
         |  mockups
         v
   +------------+
   | Developer  |
   +-----+------+
         |  code
         v
   +------------+
   |  Product   |
   +------------+

The team that’s coming#

The chain collapses, but the team doesn’t shrink to one person. You still have several people. The difference is that each of them owns a whole request on their own, from talking to the customer all the way to shipping.

Nobody is only a designer or only a backend engineer anymore. Everyone is a generalistThe Age of the GeneralistHow AI is transforming software development and why high-agency generalists will thrive in this new era of technology.aiJun 15, 2025. Everyone is kind of a manager, directing their own set of AI agentsHow to do AFK CodingA pipeline for shipping a 5-point ticket while you're away from the keyboard: spec with the human in the loop, slice into vertical tickets, run a Ralph loop with TDD per slice, refactor, then let an agent-browser do QA.aiclaude-codeagentic-coding+2May 10, 2026 to handle the design, the code, and the tests. What ties the team together isn’t a pipeline of handoffs, it’s high agency. Every person can take a need and drive it to done by themselves.

   +------------+     +------------+     +------------+
   |  Customer  |     |  Customer  |     |  Customer  |
   +-----+------+     +-----+------+     +-----+------+
         |                  |                  |
         v                  v                  v
   +------------+     +------------+     +------------+
   | Generalist |     | Generalist |     | Generalist |
   |  (request  |     |  (request  |     |  (request  |
   |     A)     |     |     B)     |     |     C)     |
   +-----+------+     +-----+------+     +-----+------+
         |                  |                  |
         v                  v                  v
   +------------+     +------------+     +------------+
   | AI  Agents |     | AI  Agents |     | AI  Agents |
   |design|code |     |design|code |     |design|code |
   |   |tests   |     |   |tests   |     |   |tests   |
   +-----+------+     +-----+------+     +-----+------+
         |                  |                  |
         v                  v                  v
   +------------+     +------------+     +------------+
   |  Product   |     |  Product   |     |  Product   |
   +------------+     +------------+     +------------+

Same team size, but instead of one idea crawling through four people, three ideas move in parallel, each one owned end to end.

Of course the real picture is more complex than three clean columns. Agents won’t only write the code. They’ll also suggest ideas for new features and auto fix bugs before anyone even looks at them. And not everything disappears. You’ll still have teams managing your infrastructure and your security, and those roles stay important. It’s the product teams specifically that will look completely differentThe Software Factory: Why Your Team Will Never Work the Same AgainWe already have everything we need to build software factories. Teams will change. The only variable is speed.aisoftware-engineeringteams+3Mar 22, 2026.

So what does this mean for the developer?#

If an agent can do the job of a developer, what happens to the role?

It changes. The clerical part of the job is dead.

If your only value to a team was converting tickets into code, I think you need to rethink your skills and the way you think about your work.

But here’s the other thing that’s obvious. An agent won’t know which features to add or which products to build. It can help, but you still need empathy. You still need to talk to customers and understand what they actually need.

That part isn’t going away.

Saying goodbye#

So after more than 8 years as a developer, it’s time to say goodbye. Goodbye to something that was fun.

But was it really fun? Was it really fun to lose days to a stupid bug, only to find out you forgot a semicolon? I think a lot of developers make the mistake of romanticizing the past.

If you still love software and love building things, the future looks promising. But if you never cared about the business, never cared about the product itself, and only cared about the technical parts, you’re going to have a hard time in this new market.