The rise of sophisticated AI models has sparked intense debate about the future of numerous professions, and software engineering is no exception. Two prominent viewpoints have emerged, dominating discussions across social media and professional circles. On one side, there’s the assertion that coding as a viable career path is rapidly becoming obsolete, with AI poised to automate code generation within a few years. Conversely, others dismiss Large Language Models (LLMs) like ChatGPT and LLaMA as mere novelties, lacking substantial utility for real-world software development.
The truth, however, is far more nuanced than these polarized perspectives suggest. Presenting such extreme views can be detrimental, particularly for individuals new to software engineering or considering it as a career. It’s crucial to explore the realistic impact of AI on this field in the coming years, offering a balanced and informed outlook.
This article aims to delve into the transformative role AI will play in software engineering, addressing the core question: Is Coding Going Away As A Career? We will examine how AI is likely to reshape the profession, rather than eliminate it entirely.
For a concise overview, here are the key takeaways:
- AI’s capabilities will continue to advance, potentially following an S-curve pattern of technological progress. However, the precise point we currently occupy on this curve remains uncertain.
- LLMs are unlikely to displace software engineers. Instead, they will serve as powerful tools to enhance the efficiency of both teams and individual developers, enabling them to achieve more with fewer resources and time.
- Effective utilization of AI tools like ChatGPT for coding necessitates providing detailed and logically structured instructions. This process mirrors the fundamental role of a programmer, albeit interacting with a novel, AI-driven language.
- If AI progresses to a stage where human involvement is entirely removed from software creation, we would have likely achieved Artificial General Intelligence (AGI). At that point, the implications extend far beyond the software engineering profession, raising significant societal challenges.
Let’s delve deeper into these points to understand the evolving landscape of coding in the age of AI.
AI Improvement and the S-Curve of Technological Progress
The advancements in Artificial Intelligence over the past year have been nothing short of remarkable. We’ve witnessed a leap from rudimentary image generation to sophisticated AI-driven tools capable of producing full-fledged videos from text prompts, as exemplified by Midjourney and similar platforms. OpenAI’s progress with the GPT models has demonstrated impressive capabilities in generating both text and code. Furthermore, experiments with AutoGPT reveal the potential for developers to create systems where LLM entities can autonomously execute complex, multi-step tasks.
Successive S-curves depicting technological advancement, suggesting AI development might follow a similar pattern of growth and plateau.
These rapid strides might create the impression of exponential progress in AI. However, technological advancement often follows a pattern described by successive S-curves. This model suggests that a technology undergoes a period of slow initial growth, followed by a phase of rapid acceleration, and eventually reaches a plateau as it matures. Breakthrough innovations can then trigger a new S-curve, starting the cycle anew at a higher performance level. When viewed broadly, this series of S-curves can resemble linear growth, but it is actually composed of iterative cycles of development.
It’s reasonable to assume that AI’s development, at least for the foreseeable future, might adhere to this S-curve pattern. This leads to a crucial question: where are we currently positioned on the current AI S-curve? Are we on the verge of exponential growth, or are we nearing a plateau in the current phase of advancement?
If I were to speculate, I would argue that we are approaching the plateau of the current S-curve for LLMs and related AI technologies. While further incremental improvements are expected, a significant breakthrough might be necessary to initiate the next phase of exponential growth.
As AI-generated content becomes more prevalent – spanning video, audio, code, and images – a growing number of people are becoming attuned to its subtle imperfections, often described as the “uncanny valley” effect. Much like many complex projects, achieving the final 10% of refinement to overcome these limitations may require a disproportionate 90% of the total effort and time.
Predicting the timeline for the emergence of the next S-curve and the resumption of exponential AI improvement is challenging and inherently uncertain.
LLMs: The Next Evolution in Integrated Development Environments (IDEs)
Returning to the realm of programming, the integration of models like OpenAI’s GPT into coding tools has been a significant development. Tools such as ChatGPT, GitHub Copilot, and Copilot X have demonstrably increased developer productivity worldwide.
However, it’s crucial to recognize that these AI-powered tools are not replacements for programmers; they are, in essence, advanced instruments in a developer’s toolkit, designed to enhance their capabilities.
I vividly recall the transformative impact of transitioning from a basic text editor like Sublime Text to a comprehensive JetBrains IDE. My productivity experienced a dramatic surge as I gained access to features like intelligent auto-completion, automated code refactoring, integrated testing frameworks, and deeper insights into project dependencies. These IDE functionalities empowered me to write cleaner, more efficient code at a significantly accelerated pace.
AI coding tools represent the next logical step in this continuous evolution of developer environments. They are augmenting, not supplanting, the role of the software engineer.
Since incorporating Copilot and ChatGPT into my personal projects earlier this year, I’ve observed a similar boost in efficiency. Many routine tasks in new projects, while not intellectually demanding, can be time-consuming. These include writing unit tests, generating frontend templates, creating boilerplate code for new classes, or formatting data outputs. With AI assistance, I can now accomplish these tasks up to ten times faster. These tools exhibit a remarkable “understanding” of my intentions, effectively scaffolding the necessary code within my projects.
Furthermore, when faced with complex function implementations or unfamiliar libraries, AI tools prove invaluable. Simply providing a descriptive comment outlining the desired functionality often prompts the AI to generate a code block that closely aligns with the requirements.
For instance, while working on a PHP application, I needed to use the FFMpeg library, known for its extensive and sometimes intricate documentation. Instead of manually navigating the documentation, I simply added a 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>A PHP code snippet illustrating how a simple comment can prompt AI to generate code using the FFMpeg library.
Upon pressing enter after this comment, the AI generated concise and functional code that I could readily integrate into my project with minimal adjustments.
The crucial point is that this saved me considerable time. Even with prior in-depth knowledge of the FFMpeg library, the time saved might have been marginal. However, in situations where I possessed general language proficiency but lacked specific library expertise, the AI’s ability to generate relevant code based on my descriptive comment proved incredibly efficient. It eliminated the need for extensive documentation review, Stack Overflow searches, or iterative trial-and-error coding.
This is where AI’s true strength in programming lies: it empowers developers to work more effectively and efficiently.
However, two important caveats are worth noting:
- Overconfidence and Inaccuracies: AI tools can sometimes exhibit overconfidence, hallucinating function arguments or methods that do not exist in the project or libraries being used. While these inaccuracies can often be corrected through iterative prompting, occasionally the AI may generate code that deviates significantly from the intended functionality. Fortunately, such instances are relatively infrequent.
- Lack of Holistic Application Understanding: Current AI models like ChatGPT and Copilot excel at generating code snippets for specific tasks based on given inputs. However, building an entire application remains a more complex undertaking. Firstly, there are limitations on input text length, even with advanced models like GPT-4, which are constrained by token limits (approximately 6,000 words for 8K tokens). Secondly, even with vector databases and AutoGPT, these models struggle to maintain consistent development styles or achieve overarching project goals in programs exceeding moderate complexity. While they can readily generate a functional to-do application, creating a more sophisticated system, such as a CRM for a barbershop with lead management, is likely to result in incomplete functionality or less-than-optimal code.
This limitation leads us to the next crucial aspect of understanding the role of programmers in the age of AI.
Programmers as Translators of Logic for Computers
If you were to ask various people for their definition of a programmer, many responses would likely converge on “someone who writes code.” While technically accurate, this definition overlooks a fundamental aspect of the profession. A programmer, software engineer, or developer—regardless of the specific title—is fundamentally a translator of logic into a language that computers can understand.
The core task of a programmer is to take a concept, idea, or workflow expressed in human language and translate it into a programming language – a language designed to eliminate ambiguity and operate within the realm of pure logic.
Consider the simple instruction: “When the button is pressed, change the background to red.”
In a team meeting, this instruction might be readily understood by everyone. However, for a computer, this statement is rife with ambiguity. Which button? Which background? What shade of red? What happens if the button is pressed again?
To eliminate this 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 instruction 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>JavaScript code demonstrating the translation of a logical instruction into a computer-understandable format for changing button background color.
If you are familiar with JavaScript and presented with this code, you could translate it back into a sentence similar to the refined instruction above. You have effectively translated JavaScript into your native language.
This act of translation is the essence of programming. It is a primary reason why I believe the profession will endure, even with the continued advancement of AI tools.
Numerous online discussions revolve around the question, “Why doesn’t ChatGPT produce the code I want?” The recurring answer is: “You need to know how to communicate effectively with it.”
If interacting with an AI tool to obtain accurate and reliable code requires using a specific language and logical structure, then we are essentially engaging in programming with natural language. This is not a novel concept; it’s simply that the sophistication of LLMs has lowered the barrier to entry.
Even if application development evolves into a process of typing prompts into tools like ChatGPT, the need to use a precise language to generate dependable and functional outputs implies that we are, in essence, still programming.
In the current landscape, attempting to build a complete application using LLMs often necessitates manually assembling and integrating code components generated by the AI. This process still constitutes programming, requiring fundamental knowledge of the programming languages involved and the architecture of the application being built.
Consider a future scenario where AI advancements eliminate the need for explicit programming languages altogether. Imagine instructing an AI: “Compile these assets and deploy them to example.com.” In such a case, the AI would act as an intermediary layer between your data and the desired outcome, bypassing the traditional programming step entirely.
This scenario, however, aligns closely with the concept of Artificial General Intelligence (AGI).
AGI and the Transformation of the Entire Labor Landscape
Let’s contemplate a hypothetical future where AI has reached a level of sophistication that minimizes or eliminates the need for human intervention in software development. Imagine an AI-powered system connected to a database (also AI-managed) where you can simply request any dashboard, data analysis, or application functionality. What would be the implications?
If AI becomes capable of autonomously handling the complexities of programming, it would likely possess the capacity to automate a vast range of creative and knowledge-worker professions. This could lead to significant global economic disruption as a substantial portion of the workforce – potentially over 60% – becomes redundant in their current roles.
At a minimum, societal adaptations like Universal Basic Income (UBI) might become necessary. In more radical scenarios, concepts like Fully Automated Luxury Communism (FALC) might be considered.
It’s important to acknowledge that the widespread adoption of such transformative AI technologies across all sectors of the economy would not be instantaneous. While businesses are constantly seeking efficiency gains and profit maximization, large segments of the business world, particularly established enterprises, tend to adopt new technologies at a slower pace than the rapid advancements in the tech industry might suggest.
Many organizations are only now adopting tools like Docker or frameworks like React. The enterprise world often moves deliberately. Even if AI tools capable of performing 90% of a development team’s tasks were available today, maintaining legacy systems and intricate, interdependent software architectures would still require human expertise for a considerable period, even after the adoption of AI-driven development methodologies.
The software engineering profession currently faces a significant demand, with approximately 100,000 open positions in the US alone. Even in a hypothetical scenario of complete automation being immediately available, widespread adoption and integration would take substantial time.
In Conclusion: The Evolving Role of Coding
This exploration into AI and the future of software engineering has been an attempt to articulate the diverse thoughts and perspectives I’ve been considering. As someone prone to anxiety, I acknowledge a degree of apprehension about the future of my profession as a software engineer.
However, I am also genuinely excited about the potential of AI-driven tools to enhance my productivity and enable me to become a more effective programmer. I encourage anyone considering or currently pursuing a career in software engineering to continue learning and embrace the evolving tools and techniques available.
I believe the coming years will witness fascinating advancements in both AI and software development. It’s an exciting time to be in this field. Based on the current trajectory, I firmly believe that a career in coding is not a dead end.
While increased developer efficiency through AI might lead to smaller team sizes and a shift in the types of roles available within established companies, the same technologies can empower startups and smaller businesses. The lower barrier to entry enabled by AI can facilitate the creation of new products and services that would have previously required significantly more time and resources.
If my assessment proves incorrect and coding becomes obsolete in the near future, then it has been a rewarding journey. In that alternative scenario, you might find me pursuing a simpler life, perhaps gardening and crafting in a cabin in the woods.
