The Future of Senior Developers in an AI-Driven World
Tags: general
Published: 2023-04-03 11:46:41

---
title: The Future of Senior Developers in an AI-Driven World
published: true
date: 2023-04-02 09:51:17 UTC
tags: General
canonical_url: https://christianheilmann.com/2023/04/02/the-future-of-senior-developers-in-an-ai-driven-world/
---

As artificial intelligence (AI) continues to advance, many are concerned about its impact on the job market, particularly for junior developers. If AI can automate many of the tasks these developers currently perform, how will we have new senior developers and architects in the future? Let’s talk about how junior developers still have crucial roles to play, and why the potential automation of their tasks doesn’t necessarily mean a lack of future senior developers and architects.

During my [talk at the Modern Webdevelopment meetup](https://www.youtube.com/watch?v=Ou8S9ovMtVw) in Microsoft last week, I got the question about how we can have Senior Developers in the future when junior roles are being replaced by machines. Here’s what I had to say.

<iframe src="https://www.youtube.com/embed/p1SaRGK9sqg" frameborder="0" allowfullscreen></iframe>

## The Role of Junior Developers in an AI-Driven World

[![AI will take our jobs - boring, repetitive jobs that don't need to be done by developers, like throwaway demo products](https://christianheilmann.com/wp-content/uploads/2023/04/Slide20.png)](https://christianheilmann.com/wp-content/uploads/2023/04/Slide20.png)

While AI-driven tools like [GitHub Copilot](https://copilot.github.com/) and [linting engines](https://webhint.io) can generate code and identify issues, junior developers still have an important part to play in this evolving landscape. These developers need to learn about potential security vulnerabilities, such as cross-site scripting (XSS) and SQL injection problems, as well as performance and accessibility issues that may arise in the given code. In other words, what you write is less important than how it affects the product.

AI-driven tools may not yet be equipped to handle these specific issues, though advances are being made in this area. It seems a natural evolution to mix code generation with automatic validation and error reporting. And to feed these error reports back into the system that generated the code to avoid repetition.

[![Machine assisted code completion augments the work of developer - it doesn't replace it](https://christianheilmann.com/wp-content/uploads/2023/04/Slide44.png)](https://christianheilmann.com/wp-content/uploads/2023/04/Slide44.png)

Even with these tools, junior developers will still need to use their knowledge and understanding to evaluate the generated code, ensuring it is secure, performs well, and works as intended. And this comes from experiences and coaching by their peers and managers.

The role of junior developers in the age of AI doesn’t disappear; it evolves. They will need to:

- Understand and identify security vulnerabilities like XSS and SQL injection problems
- Diagnose potential performance issues
- Evaluate AI-generated code for quality, security, and performance
- Hone skills needed in this new world of machine assisted content generation. One big one that comes to mind is [Prompt Engineering](https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/). Machines give better results when we ask the right questions.

## Seniority in Engineering: More Than Just Writing Code

[![Focus Shift: from writing code to reviewing code](https://christianheilmann.com/wp-content/uploads/2023/04/Slide45.png)](https://christianheilmann.com/wp-content/uploads/2023/04/Slide45.png)

The role of senior and lead developers isn’t solely about writing code or the quantity of code written. Instead, these roles involve understanding and managing the impact of code on other team members and end-users. In other words, seniority in engineering is about how a developer effectively collaborates with their team, understands user needs, and produces reliable, secure, and efficient code solutions. And to empower your team to build processes, documentation and readable code solutions.

The more I advanced in my career, the less code I wrote. Instead, I reviewed code, evaluated tools and processes and helped junior engineers to become better coders. This is a two way street: I learned a ton by teaching and by evaluating how others approached a problem I knew to have already found the “perfect solution” for.

This understanding of impact and collaboration elevates senior developers and architects beyond those who merely produce code. While AI tools can certainly make code production more efficient, these tools can’t replace the human elements of senior engineering roles.

For example, senior developers and architects often:

- Mentor and guide junior team members
- Collaborate with other developers to solve complex problems
- Manage and prioritise various development tasks
- Provide input on architectural decisions
- Understand and attend to the needs of end-users

These responsibilities require a human touch that simply cannot be replaced by AI tools.

As developers move up the career ladder from junior to senior roles to principal or architect, new challenges and opportunities arise. Some developers may prefer to avoid moving into people or product management roles, focusing instead on technical skills and contributions.

One possible solution for those who’ve reached a certain level was to invent a new role, much like how the title “Developer Evangelist” was created. These developers can then educate and inspire others while remaining deeply involved in the technical aspects of their craft.

As there is an obvious gap in the career of technical people, this may also be a good time to re-evaluate our job structures. AI can take away the level of junior developer, if that level means churning out repetitive, simple code. We could skip one level and accelerate career advancement. There is evidence that [teams using AI assisted code completion are twice as effective than others](https://arxiv.org/pdf/2302.06590.pdf), as senior engineers needed to do a lot less hand-holding. Instead, people learned by getting examples from their development environment and using it to get explanations.

## In Conclusion

The fears surrounding AI’s impact on junior developers are not unfounded. However, AI tools not only transform their roles, but also create new opportunities for them to learn, grow, and eventually become future senior developers and architects. The focus should be placed on improving collaboration, understanding user needs, and contributing to a team’s efforts to create secure, efficient, and user-centered software solutions.

It’s important to remember that seniority in engineering doesn’t solely revolve around code production. Instead, it’s about the broader impact of that code on team members and users alike. As AI continues to advance and play a larger role in the world of development, humans still have an essential role to play in shaping the future of the industry.