Meet Devin, the world’s first fully autonomous AI software engineer.

What a headline. Devin has been making a lot of noise lately, thanks to the genius marketing & PR efforts by the Cognition team. For a brief period, Devin was all everyone talked about.

But can it truly do what a software engineer does? Let’s explore it from a few different angles. But first, a few caveats:

1. This is a theoretical argument, not an empirical analysis of Devin’s capabilities.
2. We will assume Devin can actually do what it claims to do.

Breadth - the many things a software engineer does.

Software engineers perform a multitude of tasks including, but not limited to:

• Writing, debugging, and testing code
• Designing algorithms and data structures
• Architecting software systems
• Reviewing the code of their peers
• Discussing and planning project requirements with stakeholders
• Collaborating with other departments like design and product management
• Documenting software and processes for other developers and users
• Ensuring the security and performance of applications

The actual list is probably even longer. Previously, it was hard to imagine a single AI that can do all of these things, but Devin demonstrates that it has this kind of capability - it breaks large projects into smaller tasks, learns new technologies, reviews code, fixes its own mistakes, and does all of this while interacting and seeking feedback from a human.

Devin can recall relevant context at every step, learn over time, and fix mistakes. […] We've given Devin the ability to actively collaborate with the user. Devin reports on its progress in real time, accepts feedback, and works together with you through design choices as needed.

One might argue that from a breadth standpoint, AI already has the intelligence and capacity to do the many things that a software engineer can do. But can it do them well?

Context - the nuance needed to do things right.

For those who have worked on real world applications, it’s not hard to understand that “adding a button” is often not as straightforward as “adding a button”. Seemingly simple features can contain layers of complexities that come from technical details, design decision, business logic, etc. And to make matters worse, such complexities are often non-obvious and ever changing as requirements change. As a result, the developer needs to both discover such complexities and make a series of decisions or tradeoffs to account for them. They try to do so during the scoping and planning phase, but often such discoveries and decisions can only be made after work has already started. With a web of decisions - a single wrong decision can affect the rest of an entire implementation. So when the expected outcome is not reached, the engineer needs to go back and trace through previous decisions, and attribute one, or many of the decisions to the unexpected outcome. All of this is happening while upholding existing design decisions, coding standards, business logic while adjusting for changing requirements.

Most of the developers time and attention is spent on the last 20%, not the first 80%. That’s because the hard part of working in an existing system isn’t finding a solution, the hard part is finding a solution that works without breaking anything and won’t accumulate technical debt - something that is so nuanced it’s unlikely AI agents can do it today.

Productivity - the ability to do more with less.

So far, we’ve explored the likelihood of AI agent replacing software engineers by doing the same set of tasks, to the same degree of quality. However, there is another perspective - can AI replace human engineers by increasing productivity?

As a simple example - if the market only needs 100 widgets which previously required 10 workers as each worker can only produce 10 widgets per day. And a new tool comes along that makes each worker produce 20 widgets - well we only need 5 workers now. This assumes the total aggregate amount of software development work stays fixed, decreases, or increases at a slower rate than the aggregate rate of productivity gains

Generally speaking, we can understand this as:

In my opinion, this is the most likely method that AI will replace software engineers - by making a smaller subset of human engineers much more productive such that they can deliver the same output which would have required a larger team previously.

Of course, one might argue that the total amount of software development work will increase. In other words, as software eats the world, we will need more than 100 widgets. In fact, this is the status quo because more and more people are connecting to the internet, and more of our daily lives are becoming digitized. Yet on the other hand, world population is expected to decline drastically, birth rates are scarily low in most developed countries. On top of that, do we really have capacity to consume even more software on an individual basis? and should we? These are questions that touch upon macroeconomics and psychology which are complex on their own.

But perhaps it’s more relevant to ignore the macro perspective for a second, and only consider the micro level. In the short term, an average company that makes an average product is unlikely to see a drastic increase in the software development work it needs. Combine that with a struggling economy, a reduction in workforce is very likely.

Conclusion

In the short term, it’s unlikely that AI agents like Devin will replace a software engineer by doing the exact set of tasks, to the same degree of quality. In other words, you can’t substitute a human engineer with an AI agent (or even a team of AI agents). However, with a meaningful gain in productivity, it is very likely that a subset of human engineers, made more productive with the help of AI tools, will reduce the total number of engineers needed in an environment where total output required remains fixed.

In the long term, companies like Devin might just create an AI engineer that can be hired in place of a human engineer. Time will tell - but it’s certainly something both exciting and scary to think about.

What does that mean for software developers? I believe those who love building, who continue to grow their skill sets, and those who adapt to the changing world will be extremely hard to replace. In contrast, those who don’t enjoy what they do, who are satisfied with the status quo, and who resist change will be at risk of being replaced by AI. This sounds cliche because it is. It would have happened without AI. AI is simply an accelerant, and a powerful one.

At EasyCode, our mission is to help serious engineers spend more time on work that matters to them, by spending less time on boilerplate code.