The tech world is buzzing with opinions about the future of programming, especially with the rapid advancements in Artificial Intelligence (AI). Two contrasting viewpoints frequently surface on social media and tech forums. One perspective paints a bleak picture, suggesting that programming as a viable career is nearing its end, with AI soon rendering human coders obsolete. Conversely, another view dismisses current AI models like ChatGPT and LLaMA as mere novelties, lacking substantial practical value for real-world software development.
The truth, however, is far more complex and nuanced. These extreme viewpoints can be unsettling, especially for individuals who are either new to software engineering or considering it as a career. This article aims to explore the evolving landscape of programming in the age of AI, offering a balanced perspective on the changes and opportunities that lie ahead.
For those seeking a quick overview, here are the key takeaways:
- AI is on a trajectory of continuous improvement, likely following an S-curve pattern. However, the exact point we currently occupy on this curve remains uncertain.
- Large Language Models (LLMs) are unlikely to eliminate software engineering jobs entirely. Instead, they are poised to 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 precise and logically structured instructions to generate effective code. This process essentially mirrors the role of a programmer, albeit within a new, more abstract language.
- Should AI reach a level where human involvement is completely removed from software creation, we would likely have achieved Artificial General Intelligence (AGI). At that point, society would face significantly broader challenges that dwarf concerns about programming careers.
Interested in a deeper dive? Let’s explore these points further.
AI Improvement and the S-Curve
The progress in AI over the past year has been nothing short of remarkable. We’ve witnessed a leap from rudimentary digital sketches to sophisticated, AI-generated movies created from text, images, and speech, thanks to platforms like Midjourney and others. OpenAI’s advancements in the GPT model have demonstrated exceptional capabilities in generating both text and code. Experiments with AutoGPT further highlight this potential, showcasing developers using LLM entities to autonomously execute complex, multi-step tasks.
While these developments might suggest exponential growth in AI, historical trends in technological advancement tell a different story. Technological progress often follows a pattern of successive S-curves. A technology typically experiences a period of slow initial development, followed by a phase of rapid acceleration, and eventually plateaus as it reaches maturity. Subsequent iterations of the technology then initiate new S-curves, building upon previous levels of advancement. Viewed from a distance, this progression may appear linear, but it is actually composed of multiple S-curve cycles.
It’s reasonable to assume that AI’s development might also adhere to this S-curve pattern, at least in the near term. The critical question then becomes: where are we currently positioned on the AI S-curve? Are we on the cusp of exponential acceleration, or are we nearing a plateau with limited immediate progress ahead?
If I were to speculate, I would suggest we are approaching a plateau. While LLMs and related AI technologies still have room for improvement, I believe we are missing a crucial element that will require time and effort to fully realize. As AI-generated content proliferates – videos, speeches, code, images – a growing number of people are becoming adept at recognizing its “uncanny valley” characteristics. Like many ambitious projects, perfecting the final 10% of AI capabilities may demand 90% of the total effort and time.
The timeline for the next S-curve, and the resurgence of exponential improvement, is difficult to predict. No single individual can definitively answer that question.
LLMs: The Next Evolution in IDEs for Programmers
Returning to the specific context of programming, we’ve witnessed significant integration and enhancement of models like OpenAI’s GPT within the coding realm. Tools such as ChatGPT, GitHub Copilot, and the newer Copilot X are demonstrably increasing the efficiency of developers worldwide.
However, it’s crucial to understand that these AI tools are not replacing programmers; rather, they serve as powerful instruments within a programmer’s toolkit, enabling them to perform their jobs more effectively.
My personal experience transitioning from a basic text editor like Sublime Text to a comprehensive Integrated Development Environment (IDE) like JetBrains products was transformative. My productivity surged as I gained access to features like intelligent auto-completion, automated code refactoring, integrated testing frameworks, and deeper insights into project dependencies. This suite of tools empowered me to produce cleaner, more robust code at a significantly accelerated pace.
AI-powered coding tools represent the next logical step in this ongoing evolution of programmer efficiency. Since incorporating Copilot and ChatGPT into my personal projects at the beginning of this year, I’ve observed a similar boost in my workflow.
Many routine tasks in new projects, while not intellectually demanding, are time-consuming. Activities like writing unit tests, creating frontend templates, generating boilerplate code for new classes, or structuring data outputs – these can now be accomplished up to ten times faster with the assistance of AI tools. These tools seem to intuitively grasp my intentions and rapidly generate the necessary code scaffolding within my projects to achieve them.
Furthermore, when confronted with complex function implementations or unfamiliar libraries, AI assistance proves invaluable. Simply by typing a descriptive comment outlining the desired functionality, the AI typically generates a code block that effectively addresses the requirements.
For example, while working on a PHP application, I needed to utilize the FFMpeg library, known for its 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>Upon pressing enter, Copilot generated concise, functional code that I could readily integrate into my project with minimal adjustments.
This experience underscored the significant time savings these tools offer. While possessing in-depth knowledge of the FFMpeg library might have shaved off a minute or two, the AI assistance proved invaluable in bridging the gap between my general programming knowledge and specific library expertise. It eliminated the need for extensive documentation research, Stack Overflow searches, or iterative trial-and-error.
This ability to enhance programmer effectiveness is where AI’s true value in programming lies.
However, two important caveats are worth noting:
- Overconfidence: AI tools can sometimes exhibit overconfidence, occasionally suggesting function arguments or methods that do not exist within the project or the relevant libraries. While refinement through retries is often possible, the AI can occasionally deviate significantly, generating code that misses the intended functionality. Fortunately, these instances are relatively infrequent.
- Lack of Contextual Awareness: ChatGPT and Copilot excel at generating isolated code snippets that perform specific tasks based on given inputs. However, building complete, complex applications remains beyond their current capabilities. Firstly, there are limitations in the amount of text they can process, even with GPT-4’s 8K token limit (approximately 6,000 words). Secondly, even with vector databases and AutoGPT-like approaches, these models struggle to maintain a consistent development style or effectively address overarching objectives in programs exceeding moderate complexity. They can readily create a functional to-do app, but a more intricate system like a CRM for a barbershop is likely to result in a partially complete application with missing features or ineffective code.
This contextual limitation leads us directly to the next crucial point.
Programmers: Translators in the Language of Logic
Ask various people to define “programmer,” and many will likely offer responses that boil down to “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 working with a language rooted in logic.
A programmer’s core task is to translate concepts, ideas, or workflows from a human-understandable language into a language that a computer can interpret. Programming languages are meticulously designed to eliminate ambiguity and operate strictly on logical principles.
Consider the simple instruction: “When the button is pressed, change the background to red.”
In a team meeting, human team members would intuitively understand the intended meaning.
However, a computer lacks crucial details. Which button? What background? What shade of red? What happens if the button is pressed again?
To eliminate 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 hex 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, you could readily translate this code back into a human-readable sentence akin to the refined instruction above.
This act of translation lies at the heart of programming and is a primary reason why I believe the profession will endure, even with the advancement of AI tools.
Countless online discussions on forums like Stack Overflow and Reddit pose the question, “Why isn’t ChatGPT generating the code I want?” The consistent answer is: “You need to learn how to communicate with it effectively.”
If interacting with an AI tool to obtain accurate and consistent results necessitates using a specific language, then we are essentially engaging in programming using natural language. This concept is not new, but LLMs’ breadth and complexity have significantly 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 elicit reliable and functional outputs means that, at its core, programming still exists.
In the current landscape, building applications using LLMs often requires manual assembly of code pieces due to model limitations. This process still constitutes programming, demanding a fundamental understanding of the generated code’s language and its integration within the larger application structure.
But imagine a future where these complexities become trivial, where AI handles everything. You might simply instruct, “Compile these assets and deploy them to example.com.” At that point, the necessity of programming languages as an intermediary layer might seem to vanish. AI would directly bridge the gap between your intent and the desired outcome, eliminating the coding step altogether.
However, this scenario essentially describes the advent of Artificial General Intelligence (AGI).
AGI: A Paradigm Shift Beyond Programming
Let’s consider the hypothetical scenario where AI reaches a level of sophistication that eliminates the need for human intervention in programming. Imagine a system where a prompt connected to an AI-managed database can generate any dashboard, data set, or software functionality simply upon request. What implications would this have?
If AI becomes capable of autonomously handling programming tasks, it would likely possess the capacity to replace a vast range of creative and knowledge-worker professions. This could trigger a global economic downturn, as over 60% of the workforce might become redundant.
At a minimum, widespread adoption of Universal Basic Income (UBI) would become necessary. In a more extreme scenario, society might gravitate towards Fully Automated Luxury Communism (FALC).
This, of course, assumes the immediate and universal adoption of such AI technology across all businesses. While companies constantly seek to maximize profits and efficiency, the business world often operates at a slower pace than the rapid advancements in technology might suggest.
Many organizations are only now adopting tools like Docker or frameworks like React. The enterprise sector, in particular, moves deliberately. Even with AI tools capable of automating 90% of a development team’s new product work, maintaining legacy systems and intricate, interdependent software will still require human expertise for a considerable time, even after AI adoption.
The software engineering profession currently has hundreds of thousands of unfilled positions in the US alone. Even if complete automation were available today, widespread adaptation and integration would be a lengthy process.
Wrapping Up: Programming’s Evolving Future
This article has been an exploration of my thoughts on AI and its implications for the programming profession. As someone prone to anxiety, I admit to feeling some unease about the future of software engineering.
However, I am also genuinely excited about the AI-powered tools emerging to enhance productivity and empower programmers. I encourage anyone interested in or starting out in this career to continue learning and leveraging these evolving tools and techniques.
I believe we are entering an era of significant 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 dying career.
While increased efficiency driven by AI might lead to smaller development teams and fewer traditional roles within established companies, the same technology will also lower the barrier to entry for startups and smaller businesses. This will enable them to launch innovative products and services that were previously too resource-intensive to undertake.
If my assessment proves incorrect and programming becomes obsolete in the near future, then it has been a rewarding journey. In that case, you might find me in a cabin in the woods, contentedly gardening and crafting cabinetry.
