From Software Engineers to Agent Managers

About Annie Vella

Annie Vella is a lifelong computer enthusiast with two decades of hands-on engineering and technical leadership experience. Currently a Distinguished Engineer at Westpac New Zealand, she focuses on resilient systems, cross-org opportunities, and quality-first engineering processes.

In 2024, she began a part-time Master’s of Engineering in Software Engineering at the University of Auckland, researching the impact of AI on the profession itself.

The Software Engineering Identity Crisis

“Many of us became software engineers because we found our identity in building things. Not managing things. Not overseeing things. Building things. With our own hands, our own minds, our own code.

But that identity is being challenged,” wrote Annie in March 2025 in her blog post, The Software Engineering Identity Crisis, which has since been read by tens of thousands of engineers and got them thinking about this (re)defining moment in what their role means.

In this conversation, Annie dives deep into the software engineer’s identity crisis, the rise of AI agents, and how engineers can prepare for a rapidly evolving future.

The Defining Moment

When ChatGPT came out in 2022, I had this immediate reaction: Okay, this is a defining moment. This might change things a lot for software engineers.

I’ve always loved anticipating where things might go so I can help people prepare. Quickly, I started thinking about what a “new shape” of the engineering role might look like and what new skills people would need. I’ve always planned to do a master's, and not long after that, I realized that there may be a master's thesis in that.

Through my research, I’ve now spoken with hundreds of engineers and thought leaders. And what’s clear to me is that this change goes deeper than just another tool or incremental evolution. It challenges what it means to be a software engineer.

When I published my blog post about this “identity crisis,” I had dozens of people reach out saying, “You wrote down what I’ve been feeling.” That’s when I knew the shift was very real.

The Reluctant Manager

I always loved the puzzle-solving side of engineering. The idea that people pay you to solve puzzles is incredible. So when, early in my career, people suggested I move into management because I had “good people skills,” I actually took it as an insult.

I thought it meant my hard skills weren’t strong enough. I pushed the idea away for a decade.

Eventually, I hit the ceiling of my role as a senior lead engineer. The work wasn’t challenging anymore, so I finally thought, “Okay, maybe I try something different.”

But becoming a manager of people who had been my peers? That was tough. Giving feedback is tough. Managing humans, well…humans are complicated. They’re emotional. They say they’ll do something and then don’t.

It’s an entirely different job, and you have to learn a whole new skill set.

Over time, I did grow to love parts of it—seeing people grow, watching teams ship something hard, and celebrating together. But every 2–3 years, I always felt the itch to get my hands back on the keyboard. That’s the engineer–manager pendulum Charity Majors talks about. It’s real. And I encourage anyone who feels it to trust that instinct—you don’t have to stick with one role forever. Swing when you need to.

Why Are Engineers Attached to Code?

For me, engineering is the mix of systems thinking and creativity.

I love mentally modeling complex systems and visualizing how components fit together. Turning that mental model into something real, that literally runs, is still magic.

Software engineering is both scientific and creative. There are rigorous engineering principles, but within those boundaries, there’s so much room for creativity. No two engineers build a system the same way.

When AI starts abstracting away that deeply personal creative process, it’s natural that many engineers feel uncomfortable. We’re used to being the creators, not the managers of creators.

The Shift to Agent Managers

For the last decade, supply and demand shaped the industry. Demand for software skyrocketed, but we didn’t have enough engineers, so teams specialized.

What I’ve seen recently is that many engineers have been pigeonholed:
“You write the code. Here’s a Jira ticket that’s basically pseudo-code. Add a column to the DB, expose it in an API. Don’t worry about why.”

And that worries me. Because AI is very good at writing code—but not yet good at designing systems, writing specs, or validating correctness.

Now we’re being pushed back toward fundamentals:

• writing good specifications
  
• designing systems thoughtfully
  
• validating and verifying AI-produced code
  
• engineering context for agents
• writing meaningful test suites

These are all the things we should have been doing all along. AI is just forcing us to remember.

From Software Engineer to Product Builder

I’m hoping that AI brings engineers closer to users. I’m hearing the term “product engineer” everywhere for engineers who keep the customer front and center and own delivery end-to-end.

But lately I’ve also seen a new label emerging: product builder.
Not just a software engineer. Not just a product thinker. But someone who builds products in an AI-first world—with agents, with context, with orchestration.

It’s funny that we’re reinventing the label to remind ourselves what software engineering was always supposed to be.

Calibrated Trust in AI

Remind yourself: AI is just software running on hardware. Trust comes from the system around it.

In AI circles, we talk a lot about calibrated trust: trusting a system exactly as much as it deserves, no more, no less. Over-trusting leads to misuse. You accept hallucinations as truth. Under-trusting leads to disuse, and then you never get value from it. Finding that balance is a muscle you build through repeated interaction. You learn where it’s strong, where it fails, and when to double-check its work.

The Future of Engineering Work

Honestly? We don’t know what the future of engineering looks like.
By this time next year, we might have architect-agents that design systems better than we do. Agents may remote-desktop into environments and build end-to-end.

So instead of predicting the end of software engineering, I’d say the work isn’t disappearing—it’s transforming. There's an enormous opportunity for engineers who learn how to build with AI.

If you want to stay technical, my strongest advice is to learn how to build software that uses AI.
Not how to build the LLM, but how to build systems around it.

There’s a huge gap in guardrails, memory, agent safety, and secure orchestration. The next generation of engineers will define those patterns.

It’s not doom and gloom. Far from it.

This career isn’t dying. It’s evolving fast, and there are fascinating problems to solve. The engineers who stay open-minded about where they add value will thrive.