2023 has been the year of AI. Barely a week went by without some new AI service or model being announced. In this episode we'll dive into the rapidly evolving landscape of artificial intelligence and its potential impact on the world of software development. Max explores three main scenarios that could become reality in an AI-powered future. And, actually, one scenario is already reality! But the good news is: The other two scenarios are not likely to materialize any time soon.
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.
Transcript
From the show. Tap a time to play from there.
- So, 2023 is over, and it of course has been the year of AI, even though it, of course, already all started in 2022, when ChatGPT was released in November '22. But the AI pace really picked up and accelerated in '23, when loads of new AI services and products were released when barely a week went by
without Microsoft announcing some new Copilot, and therefore, of course, AI is here, and AI is here to stay and will very, very likely only become more and more powerful and hopefully helpful. But speaking of that helpfulness, what does AI mean for us developers? Will it replace us? Will it replace us this year, the next year, or maybe not at all?
That's exactly what I wanna share my opinion on. I see three main ways of AI replacing developers or having an impact on developers, you could say. And the first way it will have an impact on developers is mainly as a tool that as developers, we can use AI services like ChatGPT, but of course also GitHub Copilot, which under the hood,
uses the open AI APIs. So it uses ChatGPT under the hood, you could say. It uses the same APIs and other tools like Midjourney. As developers, we can use them to speed up our workflow to become more efficient, because AI writes parts of our code, writes code blocks, gives us suggestions, helps us debug errors, or if we're thinking about tools like Midjourney,
helps us generate assets, which we might need to build prototypes and things like that. And that's therefore one way AI could have an impact on developers, and I'd argue, already has an impact on developers because that is pretty much the the present, it's the current state that we have such AI tools that do make us developers more efficient.
So that's one possible way of AI impacting developers. Maybe we stay in that world and that's all we can expect from that AI or revolution as developers. And I will get back to that later. But of course, there also are more extreme scenarios, more dangerous scenarios, you could say. Well, for example, the second main way of AI having an impact on developers I can think of
is that AI writes much more code than it does today. Because today, as I just explained, it's mostly a utility, a helpful tool that generates some code, but not all the code. And in the future, maybe even in a not too distant future, AI may be able to generate entire applications so that it writes all the code of an application, not just individual snippets or code blocks.
And therefore, of course, it might be able to get rid of a lot more developers, almost all developers, you could say, because we maybe just need a few that tell the AI what to do and supervise the results. But we might not need as many developers as we have today because AI writes most of the code. So that's another scenario which could be dangerous for us developers. And I will of course also get back to that. But first, I wanna outline the third scenario I can think of,
and that would be a world where we maybe don't need that much code to be written. Because why would we assume that the future is about AI writing code? Why is it not about AI applications that can then directly do certain things? So we don't need specialized applications to perform certain tasks. Instead, we might have a couple of AI applications
with which we interact through voice input or written prompts, which are then able to do all kinds of things. So instead of a hotel booking website, and a flight booking website, and a website for doing online groceries, we might have one AI service, which of course would be an application, but it would just be one, with which we interact, which we then tell that we wanna book a vacation, that we need a hotel, some flights, and that we also want to order
some milk and eggs for tomorrow. And that of course would also be a possible future, and it would be a future in which we need, basically, the developers that work on those AI applications and maintain them, even that might be doable by some AI. And hence, the entire idea of people writing code and building applications might be an idea from the past in that future.
But how likely are these different futures? How likely is it that we enter one of these three scenarios? And let's maybe start with the most extreme scenario. The third one, where we don't really have a lot of applications, but where we instead have those AI applications, those AI services which perform the majority of work or which do the majority of work,
and where we therefore need basically no developers. How likely is that? And I personally don't think it's too likely. Definitely not in the very near future, but maybe also never. Maybe this is never the future we'll live in because, of course, AI will become more capable and powerful, and we will have versatile AI applications with which we can interact.
The question just is if all interactions are best done with such an AI application, and if we want such AI applications to do everything, do you want an AI you talk to, to check your account balance instead of logging into your online banking account and looking at it there? Do you want an AI to have access to your bank account? Is the question, I guess. Do you really want to book a vacation
by telling an AI what you wanna do? Is that really how you wanna do it? At least for me, it's not. I like the process of picking a hotel, looking for different flights, reading about the destination I'm traveling to. That, for me, all belongs to that vacation experience. And it's not just the experience. I don't wanna rely on an AI picking the best flight and the best hotel for me. I wanna choose it myself.
And I'm fully aware that of course, on those hotel booking websites, we also get influenced. The way those hotel recommendations are ranked is not necessarily the best way for us, but at least we have a choice. We can go through them. I don't wanna rely on an AI to do that for me. I don't trust AIs that much. I can't look into it. I don't know why it picked certain options. And these, of course, are very specific examples,
but you could come up with similar examples for basically all industries. And then it's also also possible that we have certain application areas, certain industries, where such a versatile AI might not even be the best solution. It might in some cases, be too complex to always interact with an AI instead of a specialized application that does a specific job well.
So chances are high that in probably a lot of scenarios and use cases, such a versatile AI application would be less reliable and less efficient than a specialized application that does one thing and does that thing well. For example, I don't want an AI application which I have to tell to scan the document I just put into my scanner. Having a dedicated application for that makes a lot of sense to me
because I don't wanna order groceries from that same application. I just want to scan the document I put into my scanner. And again, it's just a made up example, but you probably get my point. And that's even not all that could be mentioned here. This is maybe just my personal preference and others might disagree. But what about accountability and responsibility? If we rely on versatile AI applications, it basically means that we trust them to do things right.
Because again, looking into them is pretty hard. Sure, we might be able to come up with ways of logging how an AI came to the conclusion it came to, but even then you have to trust it that this logging is done right, because there is no deterministic code that leads to that. Instead, we all know that if we give an AI the same prompt twice, we might not necessarily get the same result twice. But even if that would change, we still would have an AI doing things,
and an AI is probably not accountable for its actions. And that's a big difference compared to a human. If you got humans writing code for an application, you have responsibility, you have accountability. And that of course is a major factor for so many industries. And kind of related to that, it of course is probably fair to assume that even if we would have a perfect world where we got a super powerful AI
that is accountable, that we all wanna use, even if that would be the world we'd be living in, we'd still have a lot of industries, and government services, and so on, that would probably not use it in the short or even midterm because we all know, at least here in Germany, but I guess it's the same all over the world, how quick certain industries, and especially government services have been
to adopt digitalization and the internet. Here in Germany, there still is a lot of stuff that has to be done on paper, not over the internet, not using digitalization. And we can only imagine how quick AI services would be adopted there. And of course then, we also would've other problems like data privacy and so on. So, I am very confident that in the near and midterm, and maybe never,
we'll be living in a world where we only interact with AI services. But that was just one extreme world. Another pretty extreme world for us developers, would be one where AI writes basically all the application code that must be written. In such a world, we would still have some developers that supervise those results, and check them and maybe fix tiny errors, or write very specific niche code,
but we wouldn't have as many developers as we do today. That would be another possible scenario. But here, again, I'm doubtful if we'll be living in such a world anytime soon. For a couple of reasons. Now, one reason is essentially the same as I just stated before, accountability, and then speed of adoption, and so on. That would be the same because if AI writes all of the code, it again, would be the question, who's responsible for that code?
Who's responsible if it contains critical bugs that might lead to severe errors? Now, you could say, |The people who supervise the AI and whose responsibility is to check the code," but how many developers would you need for such a task if we're dealing with a complex application? Would you really gain that much by using an AI then, or would it not be better to have like a similar amount of developers who use AI support
but write the code themselves? Because we all know that diving into code we have not written, of course, takes way longer to understand it than if we write code ourselves. It's a natural thing. And therefore, this problem, at least partially, might still exist. But I have an even bigger doubt. I am not convinced that anytime soon, AI will be capable enough to write entire applications on its own.
Sure, we have all seen those examples where people drew a basic website onto a napkin, scanned that, and then the AI built that. But let's be honest, these were super simple and pretty ugly examples. This is not really impressive. I mean, it's impressive that we have technology that can do that, but it's not something we have to fear when it comes to that technology replacing us for complex scenarios. Because for basic websites like this,
you didn't really need developers before. You could just use a page builder like Wix, or some content management system, and you could even build way more complex websites with those. But when we talk about more complex websites or applications in general, I am really not sure if we'll soon be in a world where AI can write all that code, make sure that all the different modules work together, extend the code in an error-free way if needed,
and cover all the different niche, cases, and specifications of those different applications. Because of course, every application is different and has certain conditions that must be met, has certain specifications that must be implemented. And AI doing all that in a pretty error-free way, in a way that's then maintainable and extendable, well, surprise me, but I'm really not convinced
that this is a world we'll be living in anytime soon. I see AI as a tool that can help us, that can write some code, but writing entire applications in a reliable, good way, I'm not so sure. And that then leads me to the last option, this first possible future I outlined before, where AI is mainly a tool for developers, where it writes some code but not all the code,
where we can use it to become more efficient. And I think that's the future we'll have in the near future. And it's actually already the present, you could say, because of course we have GitHub Copilot and so on. And for me, personally, it made me more efficient, but not by getting rid of tasks I like to do, but instead, by giving me smart suggestions, by speeding up the process of writing boilerplate code,
and therefore by really allowing me to get more done in less time. And that's the kicker here. Of course, you could now argue that this will also replace developers. Because if fewer developers can get the same work done that previously was done by more developers, there's room to decrease the number of developers, right? Yeah, maybe that is what we'll see in the short term. But in the mid and long term, chances are,
as it has always been in the history of humankind, that we'll actually see more jobs and more opportunities for people because we have better tools. In our entire history, we always kept inventing better and better tools, and that allowed people to become more efficient. And maybe if one job then needed less workforce, that same workforce was able to either move to a different job
or use those tools to innovate more, to produce extra growth. And I think that is what we'll see here. If developers can be more efficient, we might have more industries and more companies moving into the digital space and building applications. Because a company that previously might have not been able to afford a developer staff of 20 developers, might now be able to expand its business
by building applications that can now be built with only 10 developers. So it opens up new opportunities. And of course, all the opens up opportunities for individual developers. Starting your own business, your own software as a service business, for example, is probably going to get a lot easier because you can now get more work done on your own and you don't need to hire a second or a third developer to build your initial prototype.
So, I'm not even sure if it will lead to a decrease in developer workforce. Maybe in the short term. But I personally don't think that it will do that in the mid and long term. Now, ultimately, of course, like everyone else, no matter how convinced they may sound, nobody can tell you with certainty what the future will hold. We can only take a look at the past and see that there, we always had new tools and new technologies,
and they always change things, but they also pretty much always changed things to the better, made us more efficient, opened up more opportunities. And therefore, I'm very positive about the future as a developer. And I think that AI can be an amazing tool to accelerate us as a developer, to make us more efficient, and give us more opportunities that we can leverage.
GPT 6 Astra was released. It's a good model, I have to say. Especially for 3D work it seems to be a real game changer. But due to all the hype, you may be disappointed...