The tech world is buzzing with two starkly contrasting viewpoints about the future of programming. On one side, there’s a growing narrative, often amplified on social media, proclaiming programming as a dying profession. The argument is that artificial intelligence (AI) is rapidly advancing to a point where human coders will soon become obsolete, perhaps within just a couple of years. Conversely, another camp dismisses these concerns, labeling Large Language Models (LLMs) like ChatGPT and LLaMA as mere novelties – interesting toys but ultimately lacking substantial value for serious software development.
The truth, as is often the case, is far more complex and nuanced than either extreme suggests. These polarized perspectives can be particularly unsettling and anxiety-inducing, especially for individuals who are either new to the field of software engineering or considering it as a career path. Let’s delve into a more balanced exploration of how AI is likely to reshape the software engineering landscape in the years to come.
For those seeking a quick summary, here are the key takeaways:
- AI will continue its advancement, likely following an S-curve pattern, though our current position on this curve remains uncertain.
- LLMs are not poised to replace software engineers entirely. Instead, they will become powerful tools that enhance the efficiency of both teams and individual developers, enabling them to achieve more with fewer resources and in less time.
- Tools like ChatGPT excel when provided with detailed, logically structured instructions to generate effective code. This process essentially mirrors the role of a programmer, albeit interacting with a novel and somewhat esoteric “language” of prompts.
- If AI were to reach a level where human involvement is completely eliminated from software creation, we would have essentially achieved Artificial General Intelligence (AGI). At that point, the implications extend far beyond just programming careers, raising much broader societal challenges based on our current structures.
Intrigued? Let’s explore these points in more detail.
AI Improvement and the S-Curve of Technological Advancement
The past few years have witnessed extraordinary progress in the realm of Artificial Intelligence. We’ve transitioned from rudimentary AI-generated sketches to sophisticated, full-fledged movies produced from text, image, and speech prompts, largely thanks to platforms like Midjourney. OpenAI’s continuous enhancements to the GPT model have demonstrated remarkable capabilities in generating both text and code. Furthermore, innovative experiments like AutoGPT showcase the potential of developers to orchestrate LLM entities to autonomously tackle complex, multi-step tasks.
These rapid advancements might create the impression of exponential progress in AI. However, historical patterns of technological development suggest a more nuanced trajectory.
Technological progress often follows what’s known as successive S-curves. Initially, a technology experiences slow, incremental improvements. This is followed by a period of rapid acceleration and widespread adoption. Eventually, the technology matures and plateaus, with progress slowing down again. A new iteration or breakthrough then restarts this cycle at a higher overall performance level. When viewed from a distance, this succession of S-curves may appear linear, but it’s actually composed of multiple iterations of these curves.
Successive S-curves in technological development illustrate the cyclical nature of technological advancement, characterized by periods of slow initial growth, rapid acceleration, and eventual plateauing, followed by new iterations at higher performance levels.
It’s a reasonable assumption that AI development, at least in the near term, will follow a similar pattern. The crucial question then becomes: where are we currently positioned on the current S-curve for AI? Are we at the base, poised for exponential growth, or nearing the top, with limited immediate gains on the horizon?
If I were to speculate, I would suggest we are approaching the plateau of the current curve.
While further advancements in LLMs and related AI technologies are anticipated in the short term, I believe a significant breakthrough – a “missing piece” – is needed to trigger the next phase of exponential improvement. This next leap might require fundamental changes in AI architecture, training methodologies, or a combination of factors yet to be fully realized.
As AI-generated content becomes more prevalent – encompassing video, audio, code, and images – a growing number of people are becoming adept at recognizing its inherent imperfections, often described as the “uncanny valley” effect. Like many complex projects, achieving true perfection in AI may require a disproportionate amount of effort and time for that elusive final 10%.
Predicting the timeline for the next S-curve and the resurgence of exponential improvement is inherently challenging. No single individual can definitively answer this question. It depends on numerous factors, including research breakthroughs, computational advancements, and unforeseen innovations.
LLMs: The Next Evolution in Integrated Development Environments (IDEs)
Returning to the specific context of programming, we have already witnessed the significant impact and integration of models like OpenAI’s GPT within the coding ecosystem. Tools such as ChatGPT, GitHub Copilot, and the recently introduced Copilot X are demonstrably enhancing the efficiency of software developers worldwide.
However, it’s crucial to emphasize that these AI tools are not replacing programmers. Instead, they are evolving into indispensable tools within a programmer’s toolkit, empowering them to work more effectively and productively.
I vividly recall the transformative experience of transitioning from a basic text editor like Sublime Text to a fully featured JetBrains IDE. The increase in my productivity was remarkable. Suddenly, I had access to intelligent auto-completion, automated code refactoring, integrated testing frameworks, and deep insights into project dependencies. These features collectively enabled me to write cleaner, more robust code at a significantly accelerated pace.
AI-powered coding assistants represent the next logical step in this ongoing evolution of developer tools. They build upon the foundation of IDEs, offering a new layer of intelligent assistance that further streamlines the development process.
Since the beginning of this year, I’ve been actively using Copilot and ChatGPT in my personal projects, and 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 boilerplate code for automated tests, creating basic frontend templates, generating new classes, or standardizing data output formats. With the assistance of these AI tools, I can now accomplish these tasks up to ten times faster. They exhibit a remarkable ability to understand my intentions and generate the necessary code scaffolding within my project to fulfill them.
Going beyond routine tasks, I’ve also found AI invaluable for more complex coding challenges. When faced with implementing intricate function bodies or working with unfamiliar libraries, I can simply type a descriptive comment outlining my goal. The AI then typically generates a code block that effectively addresses the requirements, often with surprising accuracy.
For instance, in a recent project involving a PHP application, I needed to utilize the FFMpeg library, which has notoriously complex documentation. Instead of wading through 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>Hitting enter after writing this comment resulted in concise, functional code that I could immediately integrate into my project, requiring only minor adjustments.
The key takeaway is the significant time savings these tools provide. Even if I were intimately familiar with the FFMpeg library, manually writing the code might have only taken a few minutes less. However, because I was in that intermediate zone – familiar with PHP but not this specific library – the AI allowed me to quickly bridge the knowledge gap. I could articulate my need in plain English, and the AI provided immediately usable code, eliminating the need to spend time consulting documentation, searching Stack Overflow, or engaging in extensive trial-and-error.
This is where the true power of AI in programming lies: it empowers developers to work smarter and more efficiently.
However, two important caveats are worth noting:
-
Overconfidence: AI coding assistants can sometimes exhibit overconfidence. On multiple occasions, I’ve encountered instances where the AI hallucinates arguments or functions that simply don’t exist within my project or the libraries I’m using. While iterative prompting can sometimes nudge it in the right direction, occasionally it veers off-course and generates code that fundamentally fails to achieve the intended purpose. Fortunately, these instances have been relatively infrequent in my experience.
-
Lack of Contextual Awareness: Currently, tools like ChatGPT and Copilot excel at generating isolated code snippets that perform specific functions based on given inputs. However, architecting and building an entire application remains a more complex challenge. Firstly, there are limitations on the amount of text context these models can process at once. Even advanced models like GPT-4 have token limits (around 8,000 tokens, or approximately 6,000 words), which restricts their ability to grasp the entirety of a large project. Secondly, even with techniques like vector databases and AutoGPT, these models often struggle to maintain consistent architectural styles or effectively execute overarching directives in programs that exceed moderate complexity. They might successfully create a basic to-do app, but tackling a more intricate system like a CRM for a barbershop is likely to result in a partially functional application with missing features or ineffective code.
This limitation naturally leads us to the next critical point: understanding the fundamental role of programmers.
Programmers: Translators in the Language of Logic
If you were to ask various people to define “programmer,” you’d likely receive a range of responses, many of which would boil down to “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 responsibility of a programmer is to take a concept, an idea, or a workflow expressed in human language and translate it into a language that a computer can understand. Programming languages are specifically 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 meeting with fellow team members, this statement might be perfectly clear and intuitively understood by everyone present.
However, to a computer, this instruction is riddled with ambiguity and missing information. Which button? What background? What shade of red? What happens if the button is pressed again?
To eliminate this ambiguity, we need to refine the instruction: “When the button with the ID ‘clicky’ is pressed, change the background of that same button to a color with the hexadecimal 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>If you are familiar with JavaScript and presented with this code snippet, you could translate it back into a human-readable sentence similar to the more precise instruction above.
This process of translation – from human intention to machine-understandable code and back again – lies at the heart of programming. It is a fundamental reason why I believe the profession will endure for the foreseeable future, even with the continued advancement of AI tools.
Numerous online discussions revolve around the question, “Why isn’t ChatGPT producing the code I want?” The consistent answer invariably boils down to:
“You need to learn how to communicate with it effectively.”
If effectively utilizing AI tools requires mastering a specific language of prompts to consistently obtain accurate and desired outputs, then we are, in essence, engaging in programming using natural language. This isn’t a revolutionary concept; it’s simply that LLMs, with their broad knowledge base and complexity, have lowered the barrier to entry for this form of interaction.
Even if application development evolves to the point where it primarily involves typing prompts into tools like ChatGPT, the need for a precise and structured “prompt language” to achieve reliable and functional outputs means that the underlying activity remains fundamentally programming.
In the current landscape, attempting to build a complete application solely through LLMs, given their existing limitations, often necessitates manually assembling and integrating various code components. This process still constitutes programming, requiring a foundational understanding of the programming language used by the AI and the ability to integrate the generated code snippets into a cohesive whole.
But let’s consider a hypothetical future where this level of manual intervention becomes trivial or unnecessary, with AI automating even the integration and deployment phases. Imagine simply instructing the AI: “Compile these assets and publish them on example.com.” At that point, would programming languages themselves become obsolete? Could AI become the sole intermediary between our data and desired outcomes, eliminating the need for a separate coding step?
This scenario brings us to 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 the programming process becomes minimal, approaching zero. Imagine a system where a prompt interface is seamlessly integrated with an AI-managed database. Users could simply request any dashboard, data analysis, or application functionality imaginable, all through natural language prompts. What would be the implications then?
If AI becomes powerful enough to entirely remove human involvement and oversight from software creation, it would likely have reached a level of general intelligence capable of automating a vast spectrum of creative and knowledge-worker professions. This could trigger a significant global economic restructuring, as a substantial portion – potentially over 60% – of the current workforce might no longer be required in their traditional roles.
At a minimum, such a scenario would necessitate widespread implementation of Universal Basic Income (UBI) to address potential mass unemployment. In more radical visions, it could even pave the way for concepts like Fully Automated Luxury Communism (FALC), where automation fulfills most societal needs.
Of course, this assumes that every business across all sectors would immediately adopt and integrate this hypothetical advanced AI technology. While companies are generally driven to maximize profits and improve efficiency, the business world often adapts to technological shifts at a slower pace than the tech industry itself anticipates.
Many organizations are only now adopting technologies like Docker or frameworks like React. The enterprise world, in particular, tends to move deliberately. Even if an AI tool emerged capable of automating 90% of a development team’s tasks in creating new products, the maintenance of legacy systems and complex, interdependent software architectures would still require human expertise for a considerable time, even after – or perhaps during – the adoption of such AI systems.
The software engineering profession currently faces a significant demand, with approximately 100,000 open positions in the US alone. Even if complete automation were to become available today, the widespread adaptation and displacement of human programmers would be a gradual process spanning many years.
Wrapping Up: The Evolving Landscape of Software Engineering
This article has served as a way to organize and articulate various thoughts I’ve been contemplating regarding AI and its impact on the programming profession. As someone who identifies as an anxious individual, I won’t deny feeling a degree of uncertainty about the future of my career as a software engineer.
However, I am also genuinely excited about the potential of AI-powered tools to enhance my productivity and enable me to become a more effective programmer. I encourage anyone considering a career in software engineering, or those who are just starting out, to embrace continuous learning and actively explore the tools and techniques available to them.
I believe we are entering 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 software engineering is not a dead-end career.
While the increasing efficiency of developers may lead to smaller team sizes and a potential shift in the types of roles available within established companies, this same technology can empower startups and smaller enterprises. The reduced barrier to entry and increased productivity offered by AI can enable them to launch innovative products and services that would have previously required significantly more time, resources, and effort.
If my assessment proves incorrect, and programming does become obsolete within a few years, then it will have been a fascinating and rewarding journey. In that hypothetical scenario, you might find me pursuing a simpler life, perhaps in a cabin in the woods, tending to a garden and crafting cabinetry.
