The rise of Artificial Intelligence (AI), particularly Large Language Models (LLMs) like ChatGPT and LLaMA, has sparked intense debate about the future of numerous professions. Among these, software engineering and programming are frequently questioned, leading to two dominant viewpoints circulating on social media and tech circles.
One perspective paints a bleak picture, suggesting that programming as a viable career is rapidly approaching its end. Proponents of this view argue that AI will soon automate code generation to such an extent that human programmers will become redundant, their skills obsolete within a few years. Conversely, another viewpoint dismisses LLMs as mere novelties, entertaining but ultimately superficial tools that offer little real value to the complex process of software development.
However, the reality is far more complex and nuanced than either of these extremes suggests. For individuals entering or already working in the software engineering field, these polarized opinions can be unsettling and anxiety-inducing. As a content creator specializing in automotive technology and code interpretation at carcodereader.store, I’ve witnessed firsthand how technology evolves and reshapes industries. Drawing on this experience, let’s delve into the transformative impact AI is poised to have on the programming landscape in the coming years.
For those seeking a concise summary, here are the key takeaways:
- AI is on a trajectory of continuous improvement, likely following an S-curve pattern, though its current position on this curve remains uncertain.
- LLMs are unlikely to eliminate software engineering roles. Instead, they will serve as powerful tools that amplify the efficiency of both teams and individual developers, enabling them to achieve more with fewer resources and in less time.
- Effective utilization of AI tools like ChatGPT for code generation necessitates precise and logically structured instructions. This process mirrors the core function of a programmer – translating requirements into a language understandable by a machine, albeit in a more abstract form.
- If AI progresses to the point where human involvement becomes entirely dispensable in software creation, we will have likely achieved Artificial General Intelligence (AGI). At that juncture, the obsolescence of programming will be overshadowed by far more profound societal challenges arising from widespread automation.
Intrigued? Let’s explore these points in greater detail.
AI Improvement and the Successive S-Curves
The advancements in AI over the past year have been nothing short of remarkable. We’ve transitioned from rudimentary AI-generated sketches to sophisticated, full-fledged movies produced from text, images, and speech, thanks to platforms like Midjourney. OpenAI’s progress with the GPT models has demonstrated impressive capabilities in generating both coherent text and functional code. Furthermore, AutoGPT experiments showcase the potential of LLMs to autonomously execute complex, multi-step tasks through iterative processes orchestrated by skilled developers.
These rapid strides might create the impression of exponential progress in AI development. However, historical patterns of technological advancement suggest a more nuanced trajectory, often described by successive S-curves.
Technological progress typically unfolds in an S-curve pattern: an initial phase of slow development, followed by a period of rapid acceleration, and eventually a plateau as the technology matures. Breakthrough innovations can then trigger new S-curves, building upon previous advancements but at progressively higher levels of capability. While the zoomed-out view of technological progress might appear linear, it’s actually composed of these overlapping S-curve cycles.
It is reasonable to assume that AI development, at least for the foreseeable future, will follow a similar S-curve progression. This raises a crucial question: where are we currently situated on the AI S-curve? Are we at the cusp of exponential growth, poised for another dramatic leap forward, or are we nearing a plateau, with incremental improvements becoming harder to achieve in the short term?
If I were to speculate, I would argue that we are approaching a plateau in the current S-curve of AI development. While LLMs and related AI technologies still have room for refinement and optimization, I believe we are currently lacking a critical element that will require time and significant effort to fully realize.
As AI-generated content proliferates – videos, audio, code, images – an increasing number of people are becoming adept at recognizing its subtle imperfections, often described as the “uncanny valley” effect. Like many ambitious projects, perfecting the final 10% of AI capabilities might demand 90% of the total effort and time.
Predicting the timeline for the emergence of the next S-curve, marking the beginning of another phase of exponential AI improvement, is inherently challenging and beyond the certainty of any single individual.
LLMs: The Natural Evolution of IDEs for Programmers
Returning to the specific domain of programming, we’ve witnessed the remarkable integration and adaptation of models like OpenAI’s GPT within the coding environment. Tools such as ChatGPT, GitHub Copilot, and the newly introduced Copilot X are demonstrably enhancing the productivity of software developers worldwide.
However, it’s crucial to recognize that these AI tools are not replacing programmers; rather, they are evolving into indispensable tools in a programmer’s arsenal, empowering them to work more effectively and efficiently.
I vividly recall the transformative impact of transitioning from a basic text editor like Sublime Text to a comprehensive Integrated Development Environment (IDE) such as JetBrains. My productivity experienced a quantum leap as I gained access to features like intelligent auto-completion, automated code refactoring, integrated testing frameworks, and deeper insights into project dependencies. These IDE capabilities enabled me to produce cleaner, more robust code at a significantly accelerated pace.
AI-powered coding assistants represent the logical next step in this continuous evolution of programmer tools.
Since the beginning of this year, I’ve been actively utilizing Copilot and ChatGPT in my personal projects, and I’ve observed a similar boost in efficiency.
Many routine tasks in software development, particularly in new projects, involve activities that don’t require intense cognitive effort but are nonetheless time-consuming. These include writing unit tests, generating frontend templates, creating boilerplate classes, or formatting data outputs. With the assistance of AI tools, I can now accomplish these tasks up to ten times faster. These tools exhibit a remarkable ability to understand my intentions and rapidly generate the necessary code scaffolding within my project to fulfill them.
Furthermore, when confronted with the need to implement complex function bodies or work with unfamiliar libraries, AI assistants prove invaluable. By simply typing a descriptive comment outlining the desired functionality, the AI can generate code snippets that often closely align with the intended requirements.
For instance, in a recent project involving a PHP application, I needed to utilize the FFMpeg library, known for its extensive and somewhat intricate documentation. Instead of delving into the documentation, I simply added the following comment to my code:
<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>Upon pressing enter, Copilot generated concise and functional code that I could readily integrate into my project with minimal adjustments.
The key takeaway here is the significant time savings these tools provide. Even if I possessed in-depth knowledge of the FFMpeg library, manually writing the code might have only shaved off a minute or two. However, in situations where I have general language proficiency but lack specific library expertise, AI assistants bridge the gap, allowing me to articulate my needs and receive immediately usable code. This eliminates the need for extensive documentation research, Stack Overflow searches, or time-consuming trial-and-error.
This is where AI’s true potential in programming shines: it empowers developers to work smarter and more efficiently.
However, it’s important to acknowledge two key limitations:
- Overconfidence and Hallucinations: AI models can sometimes exhibit overconfidence, generating code that includes non-existent arguments or functions, either within my project’s codebase or external libraries. While iterative prompting can often guide the AI towards more accurate suggestions, occasionally it may produce code that completely misses the mark. Fortunately, these instances are relatively infrequent.
- Lack of Contextual Awareness: Current AI models like ChatGPT and Copilot excel at producing isolated code snippets that perform specific tasks based on given inputs. However, they still fall short of being able to autonomously develop an entire application. This limitation stems from factors such as token limits (even advanced models like GPT-4 have constraints, around 8K tokens or ~6,000 words) and the challenge of maintaining a consistent development style and achieving overarching program objectives in complex projects, even with vector databases and AutoGPT implementations. While an AI might successfully generate a functional to-do app, creating a more intricate system like a CRM for a barbershop is likely to result in incomplete functionality or ineffective code.
This last point naturally leads us to a more fundamental understanding of the programmer’s role.
Programmers: Translators in the Language of Logic
When you ask various people to define what a programmer does, many will likely offer a simplified answer: “someone who writes code.” While technically accurate, this definition overlooks a crucial aspect of the profession. A programmer, software engineer, developer – regardless of the specific title – is fundamentally a translator in the language of logic.
The core task of a programmer is to take a concept, an idea, or a workflow expressed in a human-understandable language and translate it into a language that a computer can interpret and execute. These programming languages are meticulously designed to eliminate ambiguity and operate within the strict confines of logical principles.
Consider the simple instruction: “When the button is pressed, change the background to red.”
In a team meeting, humans can intuitively grasp the intended meaning.
However, a computer requires far more specific information. Which button? Which background? What shade of red? What happens if the button is pressed again?
To remove ambiguity, we must rephrase the instruction with greater precision: “When the button with the ID ‘clicky’ is pressed, change the background color of that same button to a color with the hexadecimal value #FF0000.”
Expressed in JavaScript code, 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>If you are familiar with JavaScript and were presented with this code snippet, you could readily translate it back into a human-readable sentence, similar to the more precise version we formulated earlier.
You have effectively translated JavaScript code into your native language.
This translation process lies at the heart of programming and 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 consistently boils down to:
“You need to know how to talk to it.”
If interacting with an AI tool to obtain accurate and consistent results necessitates using a specific language, then we are essentially engaging in programming with natural language. This isn’t a novel concept, but the sophistication and breadth of LLMs have significantly lowered the barrier to entry.
Even if building an application evolves into a process of typing prompts into a tool like ChatGPT, the requirement of using a precise language to generate reliable and functional output implies that we are, in essence, still programming.
In the current landscape, attempting to construct a complete application solely through LLMs, given their inherent limitations, often necessitates manual assembly and integration of code snippets. This process still constitutes programming, demanding a foundational understanding of the generated code’s language and its appropriate placement within the overall application structure.
However, let’s consider a hypothetical future where AI advancements render such manual intervention trivial or unnecessary. Imagine a scenario where you can simply instruct an AI: “Compile these assets and deploy them to example.com.” At that point, the very need for a programming language as an intermediary step might seem to vanish. The AI would effectively become the bridge between your data and the desired outcome, bypassing the traditional coding stage altogether.
But such a capability would signify that we have essentially reached the realm of Artificial General Intelligence (AGI).
AGI: A Paradigm Shift Beyond Programming
Let’s assume that AI technology reaches a level of sophistication where human intervention in programming becomes minimal or non-existent. Imagine a system where a prompt connected to an AI-managed database can generate any dashboard, data analysis, or software functionality you request. What are the broader implications?
If AI becomes sufficiently advanced to eliminate the need for human programmers, it would likely possess the capacity to automate a vast spectrum of creative and knowledge-based professions. This could trigger a global economic upheaval, as a significant portion (potentially over 60%) of the workforce might become functionally redundant.
At a minimum, such a scenario would necessitate the widespread adoption of Universal Basic Income (UBI). In a more radical vision, it could pave the way for Fully Automated Luxury Communism (FALC).
This, of course, assumes the immediate and universal adoption of such transformative AI technology across all businesses. While companies are invariably driven to maximize profits and enhance efficiency, the reality is that the business world often adapts to technological change at a slower pace than the tech industry itself anticipates.
I am personally aware of teams that are only now adopting technologies like Docker or frameworks like React. The enterprise sector, in particular, tends to move deliberately. Even if AI tools could automate 90% of a development team’s workload in creating new products, maintaining legacy systems and intricate, interdependent software architectures would still require human expertise, both during and even after the integration of AI solutions.
The software engineering profession currently faces a substantial shortage, with approximately 100,000 open positions in the US alone. Even if complete automation were to become technically feasible today, widespread adoption and integration would be a gradual process spanning a considerable timeframe.
Wrapping Up: The Evolving Landscape of Programming
This article has served as an exploration of my own evolving thoughts on AI and its implications for the programming profession. As someone who readily admits to being prone to anxiety, I won’t deny that I harbor some apprehension about the future of my career as a software engineer.
However, my dominant emotion is excitement about the potential of AI-powered tools to enhance my productivity and enable me to become a more effective programmer. I encourage anyone considering or embarking on a career in software engineering to embrace continuous learning and actively explore the tools and techniques that are becoming available.
I believe we are on the cusp of a period of remarkable advancements in both AI and software development. It’s an exciting time to be involved in this field. And based on the current trajectory, I firmly believe that programming is not a dead-end career.
While increased developer efficiency driven by AI might lead to smaller team sizes and a shift in company hiring practices over time, the same technologies also democratize software development. Startups and smaller businesses can leverage AI to launch innovative products and services that would have previously required significantly more time, resources, and specialized expertise.
If my assessment proves incorrect, and programming does become obsolete in the coming years, then it has been a fascinating journey. You might then find me pursuing a simpler life, perhaps gardening and crafting furniture in a cabin nestled in the woods.
