It’s hard to imagine that groundbreaking software could truly captivate the attention of a battle-hardened, full-stack developer who has devoted the last two decades to building software for countless types of startup companies. After all, coding has always been a complex and ever-evolving landscape — a familiar territory that can be both challenging and, at times, tedious. And yet, OpenAI’s ChatGPT managed to do just that, blowing my mind and turning my world upside down after only a week of interaction.
The hype surrounding this new offering is hard to miss, regardless of your occupation. Naturally, as a developer who lived through the years of XML, AJAX, NOSQL, and HTML5 (or you can pick any new buzz-word coding tools), I was a skeptic. Those inflated promises to revolutionize how we code were all greatly exaggerated.
This time, however, I believe we have something that demands our collective attention.
My Research & Development
Several days ago, I set out to build the classic “TODO list” app using ChatGPT to see how it held up to simple instructions. Instead of boring you, my well-informed reader, with an initial summary of that interaction, I’ve linked the entire eye-opening session.
If you haven’t developed code using AI, that linked conversation above probably left you standing in a bit of awe. The implications of that conversation with ChatGPT are not just an intellectual exercise: I believe we must totally reevaluate how we currently develop software.
Over the years, software development has matured in ever-increasing complexity. As coding has evolved, so have the subtle intricacies of developing end-user applications. Based on my initial review, AI will doubtlessly take on many, if not all, of those issues.
Let’s do a bit of analysis on the session I linked to tease out some of the major implications.
Code Generation, Requirements & Refactoring
The first shock I received was the AI’s ability to understand what I wanted, and to generate a useable response immediately.
Take, for example, the generation it did for the API server and the saving of todos. With very little instruction, it was able to produce a working node.js backend API. Granted, any dev can do that in minutes. What was really eye-opening was its unique generation as it applied my limited requirements and instructions.
From the above session, ChatGPT initially saved todos in an array. But after I presented it with new output requirements, it obligingly moved them to an SQLite database. It was also able to restructure the database to be multiuser. All while generating new files and updating existing calls to factor that in.
Incredibly, this AI can infer requirements that I did not give in the prompt. It created specific APIs without my instruction, evidently because it found them necessary in order to complete the task. Indeed, it created the GET, POST, PUT, and DELETE APIs for todos in this manner. Apparently, it will infer requirements based on known patterns, a helpful quality for a developer who is a novice to certain types of applications.
In other instances, it selected well-known packages to implement certain features (like using Passport for social logins) and demonstrated its ability to integrate them. It even explained what steps you needed to take with its generated code, such as replacing API keys and such.
The most impressive part of my session with ChatGPT was its ability to perform several tasks that generally require a significant amount of refactoring. Some of those tasks included adding a user interface to what was originally only an API server, utilizing Vue.js and Vueitify to build the UI, tying the frontend and backend applications together, and incorporating a predictive API call to ChatGPTs APIs for todo list item completion.
The way it performed these tasks genuinely floored me. As any software developer knows, refactoring an application is often one of the most challenging tasks, requiring considerable energy and brainpower to do correctly. To my surprise, ChatGPT managed to accomplish these tasks by making appropriate changes with very little context or direction.
After some review of the output code, I found that ChatGPT did not generate a fully functional application during the session. However, I’m still very impressed with its ability to generate code inline with requirements and refactor when necessary. I have since been able to take the code it generated with minimal changes to a state where it can be debugged. Eventually, I will take the code to the completed state so that we can see how far off the original code generation was from a completed application (links to the source are included at the bottom of this article).
Evolution of software development
Now, let’s address the elephant in the room. If you’ve read through that entire chat session I linked earlier, I know one of the first things you will ask yourself may be, “Is ChatGPT coming for my job”?
The answer is not simply yes or no. My vision is that AI’s involvement with software development is going to be an evolutionary process just like it always has been for software development.
In the initial stage of this evolution, AI is likely to serve as a companion to developers over the next few years. While the required skill sets for developers may not change drastically, if AI can generate 70–90% of the necessary code, the tedious aspects of development will be significantly reduced. The focus of software creation will shift more towards understanding architecture, frameworks, integration, and strategies for launching applications in the market.
As the next phase in this evolution unfolds, I foresee productivity gains making software development more accessible and affordable for smaller businesses, resulting in a major disruption in the business landscape. At present, deploying custom software requires substantial resources. For small businesses with limited means, advances in AI-driven software development could significantly lower the barriers to entry. This shift has the potential to democratize access to tailor-made software, which has traditionally demanded significant capital investments. As AI simplifies and accelerates the development process, it could empower smaller businesses to compete more effectively in the market.
In the not-so-distant future, could the software development process be streamlined to a collaboration between a Business Analyst or Product Creators and AI, with developers stepping in only for specialized expertise? It’s entirely plausible, but we would need to witness significant advancements in this technology before reaching that point. Predicting the exact timeline for this level of AI capability remains challenging, but the potential for such a transformation is undeniably intriguing.
What we need for ChatGPTto move forward
The current challenge in utilizing ChatGPT effectively lies in its limited integration with developer tools. Relying on the ChatGPT website for coding is far from ideal. In an ideal scenario, contemporary IDEs would feature add-ons that enable seamless interaction with AI assistants. These add-ons would offer a chat-based interface for communicating with the AI, which in turn, would have the capability to modify project files directly, streamlining the development process.
With this integration, you could tell the AI things like, “Generate this new screen based on these requirements, “Modify an existing API to factor in this new business rule,” or “Add integrations with 3rd party APIs”.
The one tool I’m excited to see in action is Github Copilot X. The features touted by Copilot X seem to be in line with my own vision of all this, and a major step in the right direction.
Personally, I’ve decided it is in my best interest to adapt AI into my workflow now. It will make me more productive and, I think, ultimately happier at my job.
It is crucial for developers and software teams to consider incorporating AI into their workflows at this stage. By doing so, they can enhance productivity and job satisfaction while also staying ahead in the rapidly evolving landscape. Adapting to AI-driven development processes will be essential for professionals who wish to thrive in the industry and navigate the transformative changes happening right before our eyes.
In summary, my experimentation with ChatGPT has been an eye-opening experience. It has demonstrated the potential AI has to revolutionize software development in ways I never thought possible. While there’s still work to be done, particularly in terms of integration with developer tools, addressing security concerns, and enhancing the models to produce more accurate code. I believe the future of AI-driven software development is promising. As AI continues to evolve, we may see a shift in the skillset required for developers and the democratization of custom software development for smaller businesses. The potential impact on the software development landscape is truly exciting, and I can’t wait to see what the future holds.
Code the AI originally generated: https://github.com/cgaspard/todo-app/tree/main
Code I modified in a version that compiles and runs: https://github.com/cgaspard/todo-app/tree/compiles
Here is the pull request showing the differences between the two branches: https://github.com/cgaspard/todo-app/pull/1/files
If you’d like to follow along with the fully functional application, the changes will be committed to this branch: https://github.com/cgaspard/todo-app/tree/working