For the first time in many years, the public has recently become aware of artificial intelligence (AI) again after OpenAI released their much-publicized chatbot, ChatGPT. Something about its uncanny intelligence and human-like fluency captured people’s imaginations, and maybe even freaked out a few folks.
If you’re involved professionally in software development, you’ve no doubt seen people generating fairly complicated code automatically with ChatGPT, and other similar technologies, and wondered if there was still a future for you writing code, or if the machines would eventually replace you.
Software Developers Aren’t Going Away
If you are a software developer, I don’t think you need to worry about your job going away any time soon–at least not if you’re willing to continue to learn and grow.
Below, I’ve outlined several of the ways that human software developers and code-generating AIs are different. If you are a professional developer, or studying to become one, you will see there are things you can do to future-proof your skills against the rise of the machines. Similarly, if you’re a technology leader, I’ve provided ways that you can help your software team get ready for the future of AI.
Machine learning algorithms like ChatGPT are impressive, but their “intelligence” is borrowed. What appears to be intelligence is actually derived from being trained on mountains of data generated by humans.
They can combine concepts in impressive ways, but nothing output from a machine learning algorithm will be truly new or unique. Based on its very nature, a machine learning model will always produce derivative work based on what it has seen.
Humans are somewhat the same. After all, we have sayings like “Good artists copy, great artists steal” and “All creative work is derivative.” However, you don’t have to look back over the history of any medium for long to see that there are moments of invention which change everything that comes after them. The ability to adapt after invention is a uniquely human characteristic.
There are many examples of genius developers inventing whole new ways of doing things over the years. Think of the creation of microservices architecture or inversion of control, for example. These patterns are special because of their break with what came before them. In other words, they were not derived from the coding patterns that were common when they were invented–they are a reaction against those patterns.
AIs are simply incapable of this type of creativity. Only humans can invent something truly new and never seen before.
I recently used ChatGPT to write a poem, and I kept asking it to change one line it wrote that didn’t make much sense. For whatever reason, the machine learning algorithm which makes ChatCPT tick was totally stuck on that line and just kept adding it back into the poem.
This is a flaw of machine learning algorithms. In addition to being bad on creativity, they can’t solve complex problems without having seen the solutions (or all of a solution’s component parts) before. They can recall a solution they’ve been trained on, most likely sourced from a human, but they can’t create a new solution if a human hasn’t invented all of its parts already.
So much of software development is actually just a form of problem solving. Even as AIs become a bigger part of software development, they will not be able to solve problems the way we do.
Computers have always been good at doing the things people didn’t like or were too slow at doing ourselves. At first, that primarily meant doing math quickly (they are called COMPUTErs after all). More recently, machine learning has added other types of tasks to the list of work that computers can do more quickly than their human counterparts.
For example, if you’re learning a new development language or framework, it might be helpful to ask a machine learning model, such as ChatGPT, to summarize how to achieve a certain design pattern in that language, and answer based on the countless examples it has already seen. This saves you from a bunch of reading and researching to likely arrive at the same answer.
Developers started out writing machine instructions, such as assembly language. Later, they had more advanced languages, like C and C++, but had to manage memory themselves. Now we have quite a few more abstraction layers at our disposal:
- Very powerful and elegant programming languages
- Frameworks that do the heavy lifting for us
- Development tools to help us write and debug code
- Garbage collectors for managing our memory usage
- Compilers that automatically improve the performance of our code
Whenever a new abstraction is invented, developers can move up a layer, allowing us to write more complex software.
Machine learning algorithms that write code for us may just turn out to be that next abstraction layer that is getting added, abstracting away details and busy work so we can focus on the specific requirements, unique challenges, and business logic of our software systems.
Future-Proofing: What Developers Should Do
Look for opportunities to work on teams filled with people who are better than you. Get on one of those teams, learn what you can from whomever you can, and you will become a better problem-solver very quickly.
Try to embrace being a lifelong learner. We don’t work in a stable industry, but one that reinvents itself quickly and frequently. If you want to stay marketable, make sure you’re learning new skills and instead of being replaced by what’s invented next, you’ll be the one inventing it.
To stay relevant, developers should also focus on exercising their creativity. Learn a new platform or type of development. Learn other related skills, like how to talk to stakeholders to understand their needs and turn those needs into requirements for the software that will help solve them. Heck, even learn a musical instrument! The key is to always be learning something new to keep your mind sharp and ready to learn.
Know what tools AI offers you to become a better programmer so it’s your friend and not your enemy, and practice using them so you get better at it. You should also know how to use the different types of AI in your projects, so you can hit the ground running when you need one. Finally, familiarize yourself with the offerings on your favorite cloud platforms, such as Azure AI, AWS AI, and OpenAI API.
Future-Proofing: What Technology Leaders Should Do
Technology leadership should try to hire teams with diverse experience levels and look for ways to organize those teams so that mentorship happens naturally. The experienced developers on your team will have solved more problems, and therefore be better at it. Your less experienced developers can watch and learn from the experienced ones and before you know it, you’ll have a whole team of experienced problem-solvers.
Leadership should also make sure their software developers are getting access to the best tooling and training so they can prepare themselves for the future. Encourage your team to use the AI tools available to them already, such as Visual Studio’s Intellicode or GitHub’s Copilot.
Look for opportunities to add AI functionality to your software in ways that enhance the experience for the humans using it. A good example of this is how Microsoft is incorporating ChatGPT technology into its Edge browser and Bing search engine.
While a lot of solutions that use the latest buzzword feel like solutions in search of a problem, Microsoft’s AI approach is a perfect example of how AI can revolutionize something stagnant. Even though internet search hasn’t really changed much in 20 years, Microsoft is doing it in a way that feels so integral and natural you wonder why it wasn’t just done like this before.
We don’t have to fear artificial intelligence if it’s on our side and we know how to use it as a tool to improve our software. Get to know AI and what it is good at, and focus your attention on the things humans do better.
With these perspectives, you will quickly find that AI becomes an ally of your software teams, and not your enemy.