The tech world is buzzing with two dominant narratives about the future of programming. On one side, there’s a growing sentiment that programming as a viable career is on its way out, suggesting that artificial intelligence will soon render human coders obsolete. Conversely, others dismiss Large Language Models (LLMs) like ChatGPT and LLaMA as mere novelties, fun experiments with limited practical application for serious software development.
The truth, as is often the case, is far more complex. These extreme viewpoints can be unsettling, especially for those new to software engineering or considering it as a profession. Let’s delve into the nuanced reality of how AI is likely to reshape the software 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, although its current position on this curve remains uncertain.
- LLMs are unlikely to eliminate software engineering jobs. Instead, they will become powerful tools, boosting the efficiency of both teams and individual developers, enabling them to achieve more with fewer resources and time.
- Effective utilization of tools like ChatGPT still requires detailed, logical instructions – essentially, a new form of programming in a more abstract language.
- If AI evolves to completely remove humans from software creation, we will have achieved Artificial General Intelligence (AGI). At that point, the implications extend far beyond just programming, raising much larger societal questions.
Intrigued? Let’s explore these points in more detail.
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 AI-generated images to sophisticated, full-fledged movies crafted from text prompts, images, and speech, thanks to platforms like Midjourney. OpenAI’s advancements in GPT models have demonstrated impressive capabilities in generating both text and code. Furthermore, experiments with AutoGPT showcase the potential of AI agents to autonomously tackle complex, multi-step tasks.
These advancements might lead one to believe in exponential progress in the AI field. However, historical patterns of technological development suggest a more nuanced trajectory.
Technological progress often follows a pattern described by successive S-curves, also known as sigmoid curves. A technology typically begins with slow, incremental improvements, followed by a period of rapid acceleration, and eventually plateaus as it reaches maturity. Subsequent iterations and breakthroughs then initiate new S-curves, building upon the previous ones but at a higher overall performance level. Viewed from a distance, this progression might appear linear, but it’s actually composed of numerous S-curve cycles.
It’s reasonable to assume that AI’s development, at least for the foreseeable future, will adhere to this S-curve pattern. The crucial question then becomes: where are we currently positioned on the current AI S-curve? Are we at the cusp of exponential growth, poised for a rapid ascent, or are we nearing a plateau, with limited immediate gains on the horizon?
If I were to speculate, I’d argue we are approaching the plateau phase.
While LLMs and related AI technologies still have room for improvement, I believe we are currently missing a critical element that will require time and significant effort to fully realize.
As AI-generated content proliferates – be it video, audio, code, or images – a growing number of people are becoming adept at recognizing its subtle imperfections, the so-called “uncanny valley” effect. Like many ambitious projects, perfecting the final 10% will likely demand 90% of the total effort.
The timeline for the next S-curve, the point at which exponential improvement resumes, is uncertain. It’s a question that defies any single definitive answer.
LLMs: The Next Evolution in Integrated Development Environments (IDEs)
Returning to the core discussion about programming, we’ve observed the remarkable integration and adaptation of models like OpenAI’s GPT within the coding sphere. Tools such as ChatGPT, GitHub Copilot, and the newly introduced Copilot X are demonstrably enhancing the efficiency of developers worldwide.
However, it’s crucial to understand that these AI tools are not replacing programmers. Instead, they function as powerful instruments in a developer’s toolkit, empowering them to perform more effectively.
I recall the transformative impact of transitioning from a basic text editor like Sublime Text to a comprehensive JetBrains IDE. My productivity experienced a quantum leap. Suddenly, I had access to intelligent auto-completion, automated code refactoring, integrated testing frameworks, and deep insights into project dependencies. This suite of features enabled me to produce cleaner, more robust code at an unprecedented speed.
AI-powered coding tools represent the next logical step in this continuous evolution of developer efficiency.
Since the beginning of this year, I’ve been incorporating Copilot and ChatGPT into my personal projects, and I’ve witnessed a similar boost in my own productivity.
Many routine tasks in new projects, while not intellectually demanding, are nevertheless time-consuming. These include writing boilerplate code for automated tests, designing basic frontend templates, creating new classes, or formatting data outputs. With the assistance of these AI tools, I can now accomplish these tasks up to ten times faster. They seem to intuitively grasp my intentions and generate the necessary scaffolding code within my project to realize them.
Furthermore, when faced with the challenge of developing a complex function or working with an unfamiliar library, I can simply input a concise comment outlining the desired functionality. The AI then generates a code block that is often remarkably close to fulfilling my requirements.
For instance, in a recent PHP project involving video processing, I needed to utilize the FFMpeg library, which has notoriously complex documentation. Instead of diving into documentation, I simply wrote the following comment within 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, functional code that I could readily integrate into my project with minimal adjustments.
The undeniable outcome was a significant time saving. Even if I possessed in-depth knowledge of the FFMpeg library, perhaps I could have shaved off a minute or two. However, in this scenario where I had general language proficiency but lacked specific library expertise, AI bridged the gap. I could articulate my needs effectively and leverage the AI-generated code immediately, circumventing the need to pore over documentation, search Stack Overflow, or engage in extensive trial-and-error.
This is where the true power of AI in programming emerges – it empowers you to work smarter and more efficiently.
However, two key caveats are worth noting:
- Overconfidence and “Hallucinations”: AI tools can exhibit overconfidence, sometimes suggesting arguments or functions that simply don’t exist within the project or utilized libraries. While often correctable with a few retries, occasionally, the AI veers off course entirely, generating code that fails to achieve the intended purpose. Thankfully, these instances are relatively infrequent.
- Lack of Contextual Awareness: Current LLMs like ChatGPT and Copilot excel at generating code snippets for specific functions based on given inputs. However, building an entire application remains a more complex undertaking. Firstly, there are limitations on input text length, with even GPT-4 restricted by an 8K token window (roughly 6,000 words). Secondly, despite advancements in vector databases and AutoGPT, these models struggle to maintain consistent development style or achieve overarching program objectives for projects exceeding moderate complexity. They might successfully create a simple to-do app, but a more intricate system like a CRM for a barbershop is likely to start promisingly but ultimately fall short in functionality or code quality.
This last point directly leads us to the next crucial perspective.
Programmers: Translators in the Language of Logic
If you were to ask various people to define “programmer,” many responses would likely converge on “someone who writes code.” While technically accurate, this definition overlooks a significant aspect of the profession. 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 meticulously 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, fellow humans might intuitively grasp the intended meaning.
However, for a computer, this instruction is riddled with ambiguity. Which button? Which background? What shade of red? What happens if the button is pressed again?
To eliminate 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>If you’re familiar with JavaScript and presented with this code, you could translate it back into a sentence similar to the refined instruction above.
You’ve essentially translated JavaScript 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 advancements in AI tools.
Countless online discussions revolve around the question, “Why isn’t ChatGPT generating the code I want?” The recurring answer boils down to:
“You need to know how to communicate with it effectively.”
If interacting with these tools requires using a specific language to consistently obtain accurate and reliable results, then we are, in essence, programming with natural language. This isn’t a fundamentally new paradigm; it’s just that LLMs, with their breadth and sophistication, are lowering the barrier to entry.
Even if application development evolves into primarily typing prompts into tools like ChatGPT, the need to use a precise language to generate dependable, functional output means that programming remains a core skill.
In the current landscape, attempting to build a complex application solely with LLMs often necessitates manual assembly and integration of AI-generated code snippets. This process still constitutes programming, requiring a foundational understanding of the generated code’s language and how to piece together the different components.
But let’s imagine a future where even this level of manual intervention becomes trivial, where AI automates the entire process. You simply instruct, “Compile these assets and deploy them to example.com.” At that stage, the traditional concept of a programming language might become obsolete. The AI could serve as the intermediary between your data and desired outcome, bypassing the explicit coding step entirely.
However, such a scenario fundamentally implies we’ve reached the realm of Artificial General Intelligence (AGI).
The AGI Scenario: Broader Societal Transformation
Let’s consider the hypothetical scenario where AI has become so advanced that human intervention in programming is virtually eliminated. Imagine an AI-powered system connected to a database (also AI-managed) where users can simply request any dashboard, data set, or program functionality through natural language prompts. What would be the implications?
If AI achieves the capacity to fully automate programming, it would likely extend its reach to automate a vast spectrum of creative and knowledge-worker professions. This could trigger a global economic upheaval, potentially rendering over 60% of the workforce redundant.
At the very least, societal structures would need to adapt, likely necessitating the implementation of Universal Basic Income (UBI), or in a more radical vision, Fully Automated Luxury Communism (FALC).
This transformative scenario assumes rapid and universal adoption of AI technology across all sectors. While businesses are perpetually seeking efficiency and profit maximization, the reality is that many sectors, particularly within the enterprise world, adopt technological changes at a slower pace than the tech industry often anticipates.
I’m aware of teams that are only now adopting tools like Docker or frameworks like React. The enterprise world, in general, operates at a considerably slower cadence. Even with the advent of AI tools capable of automating 90% of a development team’s workload in new product development, maintaining legacy systems and intricate, interdependent software will still require human expertise, both during and even after the widespread adoption of AI.
The software engineering profession currently faces a substantial skills gap, with approximately 100,000 open positions in the US alone. Even if complete automation were to become available today, a considerable timeframe would be needed for full adaptation and integration across all industries.
Wrapping Up: The Evolving Landscape of Programming
This article has served as a platform to articulate various thoughts I’ve been contemplating regarding AI and its impact on the programming profession. As someone prone to anxiety, I won’t deny feeling some apprehension about the future of my career as a software engineer.
However, I am also genuinely excited about the emerging tools designed 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 continue learning and embracing the tools and techniques available.
I anticipate fascinating advancements in both AI and software development in the coming years. It’s an exhilarating time to be part of this field, and based on the current trajectory, I firmly believe that programming is not a dying career.
While increased efficiency driven by AI may lead to smaller development teams and potentially fewer traditional company roles, the same technology also lowers the barrier to entry for startups and smaller businesses. They can leverage AI to launch new products and services that previously would have demanded significantly more time and resources.
Of course, if my analysis proves incorrect, and programming becomes obsolete in the near future, it will have been a rewarding journey. In that case, you might find me in a cabin nestled in the woods, contentedly engaged in gardening and crafting cabinetry.
