The tech world is buzzing with two very distinct viewpoints about the future of software engineering. On one side, you hear voices proclaiming that coding as a viable career is on its last legs, suggesting that in just a few years, artificial intelligence will render human-written code obsolete. On the other, there’s a camp that dismisses Large Language Models (LLMs) like ChatGPT and LLaMA as mere novelties, fun but ultimately lacking substantial value for real-world software development.
The reality, as is often the case, is far more complex. These extreme perspectives can be unsettling, especially for individuals who are either new to the software engineering field or considering it as a career. Let’s delve into the anticipated changes AI will bring to the software development landscape in the coming years and address the question: is coding truly becoming a dying career?
For those seeking a quick summary, here are the key takeaways we’ll explore:
- AI will continue to advance, likely in an S-curve pattern, though our current position on that curve remains uncertain.
- LLMs are unlikely to replace software engineers. Instead, they will enhance the efficiency of both teams and individual developers, enabling them to achieve more with fewer resources and time.
- Effective use of AI tools like ChatGPT requires detailed and logical instructions to generate quality code. This is fundamentally akin to programming, just utilizing a novel, specialized language of prompts.
- If AI reaches a level where human involvement is entirely removed from software creation, we will have likely achieved Artificial General Intelligence (AGI). At that point, society will face much larger, systemic challenges that overshadow career concerns.
Intrigued? Let’s explore these points further.
AI Improvement and the S-Curve of Technological Advancement
The progress in Artificial Intelligence over the past year has been nothing short of remarkable. We’ve witnessed a leap from rudimentary digital sketches to fully realized, generated films based on text, images, and speech, thanks to platforms like Midjourney and others. OpenAI’s advancements in the GPT model have demonstrated impressive capabilities in both text and code generation. Furthermore, experiments with AutoGPT reveal the potential for developers to create systems where LLM entities can autonomously execute complex, multi-stage tasks.
These developments might give the impression of exponential growth in AI. However, history suggests that technological progress often follows a pattern of successive S-curves.
Alt text: Diagram illustrating successive S-curves in technological development, showing periods of slow initial growth, rapid acceleration, and eventual plateauing, indicating a cyclical pattern of technological advancement.
This model describes a cycle where a technology experiences slow initial improvement, followed by rapid acceleration, and then a gradual plateau as it matures. Subsequent innovations then trigger new S-curves, each starting at a higher overall level. Viewed from a distance, this progression appears linear, but it’s actually composed of these recurring S-curve cycles.
It’s reasonable to assume that AI’s development will, at least for the foreseeable future, follow this S-curve pattern. The crucial question then becomes: where are we currently positioned on the present curve? Are we on the cusp of exponential growth, or nearing a plateau with limited immediate advancement?
If I were to speculate, I’d wager we are nearing the plateau phase.
I believe that while LLMs and related AI technologies still have room for refinement, a significant leap forward requires overcoming a fundamental hurdle that will take considerable time and effort.
As AI-generated content becomes more prevalent—whether video, audio, code, or images—the public’s ability to discern its “uncanny valley” qualities also increases. Like many ambitious projects, achieving the final 10% of polish and genuine breakthrough will likely demand 90% of the total effort.
Predicting when the next S-curve will begin, initiating another phase of exponential improvement, is challenging. No single individual can definitively answer that.
LLMs: The Next Evolution in Integrated Development Environments (IDEs)
Returning to the realm of programming, we’ve witnessed remarkable advancements in the integration of models like OpenAI’s GPT into the coding process. Tools such as ChatGPT, GitHub Copilot, and now Copilot X are demonstrably boosting developer productivity worldwide.
However, it’s crucial to understand that these AI tools are not replacing programmers; they are enhancing them. Think of them as sophisticated instruments in a developer’s toolkit, empowering them to work more effectively.
I vividly recall the transformative experience of transitioning from a basic text editor like Sublime Text to a comprehensive JetBrains IDE. My productivity surged immediately. Suddenly, I had access to intelligent auto-completion, automated refactoring, integrated testing frameworks, and deep insights into project dependencies. This suite of features enabled me to produce cleaner, more robust code at a significantly faster pace.
These AI-powered coding assistants represent the next logical step in this continuous evolution of development tools.
Since the beginning of this year, I’ve incorporated Copilot and ChatGPT into my personal projects and have observed a similar boost in efficiency.
Many routine tasks in new projects, while not intellectually demanding, are time-consuming. Creating unit tests, scaffolding frontend templates, generating boilerplate code for new classes, or formatting data outputs – these tasks are now expedited dramatically with AI assistance. These tools seem to intuitively grasp my intentions and generate the necessary code structures within my projects to fulfill them.
Furthermore, when faced with complex function implementations or unfamiliar libraries, AI tools prove invaluable. By simply typing a descriptive comment outlining the desired functionality, the AI often generates code blocks that closely meet the requirements.
For instance, in a recent PHP project involving the FFMpeg library—known for its intricate documentation—I simply entered the following comment:
<span>public</span> <span>function</span> <span>formatVideo</span><span>(</span><span>$video</span><span>)</span> <span>{</span> <span>// use ffmpeg to convert the video to a gif</span> <span>}</span>Alt text: Code snippet showing a PHP function with a comment instructing AI to use ffmpeg to convert a video to GIF format, illustrating AI-assisted code generation from natural language comments.
Upon pressing enter, the AI produced functional code that, with minor adjustments, was readily usable within my project.
The key takeaway here is the significant time saved. Even if I possessed detailed knowledge of the FFMpeg library, I might have shaved off only a minute or two manually coding. However, in that intermediate zone—familiar with the language but not the specific library—AI bridged the gap. I could clearly articulate my needs and leverage the AI-generated code immediately, bypassing time-consuming documentation research, Stack Overflow searches, or trial-and-error coding.
This highlights the true strength of AI in programming: it empowers you to work smarter and more efficiently.
However, two important caveats are worth noting:
- Overconfidence: AI tools sometimes exhibit overconfidence, occasionally suggesting arguments or functions that don’t exist within the project or utilized libraries. While often correctable with minor adjustments and retries, occasionally, the AI veers off course, generating code that simply doesn’t achieve the intended purpose. Fortunately, these instances are relatively infrequent.
- Lack of Contextual Awareness: Current AI models like ChatGPT and Copilot excel at generating code snippets for specific, isolated tasks based on given inputs. Developing an entire application remains a more complex challenge. Firstly, there are limitations on text input length, as even GPT-4 is constrained by token limits (approximately 6,000 words). Secondly, even with vector databases and AutoGPT, these models struggle to maintain consistent development style or effectively execute overarching directives in programs exceeding moderate complexity. They can capably create a to-do app, but a more intricate system like a CRM for a barbershop is likely to start well but ultimately fall short in functionality or code coherence.
This last point naturally leads us to the next crucial aspect of the programmer’s role.
Programmers: Translators in the Language of Logic
Ask various people what defines a programmer, and you’ll likely get many answers converging on “someone who writes code.” While not incorrect, this definition is incomplete. A programmer, software engineer, developer—regardless of the title—is fundamentally a translator in the language of logic.
The core task of a programmer is to take a concept, idea, or workflow expressed in human language and translate it into a language that a computer can understand. Programming languages are designed to eliminate ambiguity and operate purely on logical principles.
Consider the simple instruction: “When the button is pressed, change the background to red.”
In a team meeting, everyone might intuitively grasp the intended meaning.
However, a computer lacks this intuition and requires far more detail. Which button? What background? Which shade of red? What happens if the button is pressed again?
To remove ambiguity, we must refine the instruction: “When the button with the ID ‘clicky’ is pressed, change the background color of that same button to the hexadecimal color value #FF0000.”
Expressed in JavaScript, this becomes:
<span>document</span><span>.</span><span>getElementById</span><span>(</span><span>'</span><span>clicky</span><span>'</span><span>).</span><span>addEventListener</span><span>(</span><span>'</span><span>click</span><span>'</span><span>,</span> <span>function</span><span>()</span> <span>{</span> <span>this</span><span>.</span><span>style</span><span>.</span><span>backgroundColor</span> <span>=</span> <span>"</span><span>#FF0000</span><span>"</span> <span>})</span>Alt text: JavaScript code snippet demonstrating how to change the background color of a button when clicked, illustrating the translation of a simple instruction into precise programming language.
If you understand JavaScript and were presented with this code, you could translate it back into a human-readable sentence, perhaps similar to the refined instruction above.
You have translated JavaScript back into your native language.
This translation process is the heart of programming and a primary reason why I believe the profession will endure, even with advanced AI tools.
Numerous online discussions revolve around the question: “Why doesn’t ChatGPT generate the code I want?” The consistent answer is:
“You need to know how to communicate with it effectively.”
If interacting with an AI tool to obtain accurate results consistently requires using a specific language, then we are, in essence, programming with natural language prompts. This isn’t a revolutionary concept; it’s simply that LLMs have lowered the barrier to entry due to their breadth and complexity.
Even if application development evolves into primarily typing prompts into tools like ChatGPT, the necessity of using a precise language to ensure reliable and functional output means we are still fundamentally engaged in programming.
In the current landscape, attempting to build a complete application using LLMs, given their limitations, often necessitates manually assembling parts of the code. This still constitutes programming, requiring a basic understanding of the generated code’s language and how to integrate these pieces.
But what if AI advances to the point where these manual steps become trivial or obsolete? Imagine stating, “Compile these assets and deploy them to example.com.” At that point, why even need a programming language? The AI could become the intermediary between your data and the final output, eliminating the programming step entirely.
This scenario leads us to the concept of Artificial General Intelligence (AGI).
AGI Reshapes Everything
Let’s envision a future where AI is so advanced that human intervention in programming becomes almost unnecessary. You could have a prompt interface connected to an AI-managed database, enabling you to request any dashboard, data set, or program functionality simply by asking. What then?
If AI becomes capable of removing human oversight from programming, it will likely have reached a point where it can replace most creative and knowledge-based professions. This could trigger a global economic downturn as over 60% of the workforce becomes potentially redundant.
At a minimum, we would require Universal Basic Income (UBI), or perhaps even the more radical concept of Fully Automated Luxury Communism (FALC).
This, of course, assumes that every business globally would immediately adopt this technology. While companies constantly seek to maximize profits and efficiency, the business world generally adapts at a slower pace than the rapid advancements in technology might suggest.
I know teams that are only now adopting tools like Docker or frameworks like React. The enterprise sector moves deliberately, and even with a tool capable of automating 90% of a development team’s workload for new products, maintaining legacy systems and intricate, interdependent software will remain crucial during and even after AI adoption.
The software engineering profession currently has approximately 100,000 open positions in the US alone. Even if complete automation were available today, widespread adoption and integration would take considerable time.
Wrapping Up
This article served as a way to organize my thoughts on AI and its implications for the programming profession. As someone prone to anxiety, I admit to feeling some unease about my future as a software engineer.
However, I am also genuinely excited about the potential of AI tools to enhance my productivity and make me a more effective programmer. I encourage anyone considering or starting a career in software engineering to continue learning and embrace the tools and techniques available.
I believe the coming years will bring fascinating advancements in both AI and software development, making it an exciting time to be in this field. Based on the current trajectory, I confidently assert that software engineering is not a dying career.
While increased efficiency through AI might lead to smaller development teams and fewer traditional company roles, it also empowers startups and smaller businesses to launch innovative products and services that previously demanded significantly more time and resources.
If my predictions are entirely wrong, and programming becomes obsolete in a few years, well, it’s been a rewarding journey. You can then find me happily retired in a cabin in the woods, pursuing gardening and cabinet making.
