The digital age is awash with opinions, particularly on social media, about the trajectory of various professions in the face of rapidly advancing Artificial Intelligence (AI). Among the most debated is the field of programming. Two prominent viewpoints dominate the discussion: one, that programming is becoming obsolete, destined to be replaced by AI within years; the other, that Large Language Models (LLMs) like ChatGPT are mere novelties, offering little practical value to software development.
These contrasting perspectives can be unsettling, especially for individuals who are new to software engineering or considering it as a career path. The reality, however, is more complex and less alarming than either extreme suggests. This article aims to delve into the nuanced ways AI is poised to reshape the programming landscape in the coming years, offering a balanced and informed outlook.
For those seeking a quick overview, here are the key takeaways:
- AI’s capabilities will continue to advance, likely following an S-curve pattern of growth, though our current position on this curve remains uncertain.
- LLMs are not expected to eliminate software engineering jobs. Instead, they will serve as powerful tools, enhancing 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 necessitates detailed and logically structured instructions, essentially mirroring the core skills of a programmer but applied to a novel, AI-interaction language.
- Should AI evolve to a point where human involvement in software creation becomes entirely redundant, we would have effectively reached Artificial General Intelligence (AGI). At this juncture, the implications extend far beyond just programming, presenting profound societal challenges given our current structures.
Intrigued? Let’s explore these points in more detail.
AI Improvement and the S-Curve: Understanding the Pace of Progress
The past few years have witnessed remarkable strides in AI development. We’ve moved from rudimentary AI-generated sketches to sophisticated, full-fledged movies created from text prompts, images, and speech, exemplified by platforms like Midjourney. OpenAI’s advancements in the GPT model have demonstrated significant potential in both text and code generation. Furthermore, experiments with AutoGPT showcase the capabilities of skilled developers in creating processes that leverage LLM entities to autonomously tackle complex, multi-step tasks.
These advancements might create the impression of exponential progress in AI. However, technological progress historically tends to follow successive S-curves.
Alt text: Diagram illustrating successive S-curves in technological development, showing periods of slow initial growth, rapid acceleration, and eventual plateauing, with each new curve starting at a higher level.
This model suggests that a technology progresses slowly initially, then experiences a period of rapid growth, before eventually plateauing. Subsequent iterations of the technology then restart this cycle, but at a higher overall performance level. 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, at least for the foreseeable future, might follow this pattern. This leads to a crucial question: where are we currently situated on the current S-curve for AI? Are we at the bottom, poised for exponential acceleration, or nearing the top, with limited near-term advancement potential?
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 critical element that will require time to fully develop. As AI-generated content becomes more prevalent – across video, audio, code, and images – a growing number of people are becoming attuned to its subtle imperfections, often described as the “uncanny valley.” Like many complex projects, perfecting the final 10% of AI’s capabilities may require 90% of the total effort and time.
Predicting when the next S-curve will begin and spark another phase of exponential improvement is challenging and inherently uncertain.
LLMs: The Next Evolution in IDEs for Programmers
Returning to the specific domain of programming, we’ve observed the remarkable integration of models like OpenAI’s GPT into coding tools. Platforms such as ChatGPT, GitHub Copilot, and Copilot X are already enhancing the productivity of developers worldwide.
However, it’s crucial to emphasize that these AI tools are not replacing programmers; they are augmenting them. They are sophisticated instruments in a programmer’s toolkit, designed to enable them to work more effectively.
I vividly recall the transformative experience of transitioning from a basic text editor like Sublime Text to a comprehensive Integrated Development Environment (IDE) such as JetBrains. The increase in productivity was astounding. Suddenly, I had access to intelligent auto-completion, automated code refactoring, integrated testing frameworks, and deep insights into project dependencies. This suite of features 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 start of this year, I’ve experienced a similar boost in efficiency. Many routine tasks in new projects, tasks that are not intellectually demanding but consume considerable time, are now streamlined. Creating unit tests, generating frontend templates, scaffolding new classes, or formatting data outputs – these tasks are now completed up to ten times faster with AI assistance. These tools possess an uncanny ability to “understand” my intentions and generate the necessary code scaffolding within my project to realize them.
Furthermore, when faced with the challenge of developing complex function bodies or working with unfamiliar libraries, AI has proven invaluable. By simply typing a descriptive comment outlining the desired functionality, the AI typically generates a code block that closely aligns with the requirements.
For instance, while working on a PHP application, I needed to utilize the FFMpeg library, known for its extensive but complex documentation. Instead of wading through documentation, I simply wrote:
<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 this comment produced functional code, requiring only minor adjustments, that seamlessly integrated into my project.
The undeniable fact is that this saved me significant time. Even with in-depth knowledge of the FFMpeg library, perhaps a minute or two could have been shaved off. However, in this “in-between” state – familiar with the language but not the specific library – I could clearly articulate my needs to the AI and leverage the generated code immediately. This eliminated the need for extensive documentation review, Stack Overflow searches, or time-consuming trial-and-error.
This is where AI’s true value in programming emerges: it empowers programmers to work smarter and more efficiently.
However, two important caveats are worth noting:
- Overconfidence and Hallucinations: AI models can sometimes exhibit overconfidence, leading to “hallucinations” – generating code that includes non-existent arguments or functions within the project or utilized libraries. While such instances are relatively infrequent, they do occur. Sometimes, iterative prompting can steer the AI back on track, but occasionally, it may generate code that completely misses the mark.
- Lack of Holistic Project Understanding: Current LLMs excel at generating code snippets that perform specific functions based on given inputs. However, architecting and developing an entire application remains a more complex challenge. Firstly, there are constraints on input text length, even for advanced models like GPT-4, which are limited to around 8,000 tokens (approximately 6,000 words). Secondly, even with the use of vector databases and AutoGPT, these models struggle to maintain a consistent development style or effectively execute overarching directives for programs exceeding moderate complexity. They might successfully create a 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 segments.
This last point brings us to a fundamental aspect of programming and the role of the programmer.
Programmers: Translators in the Language of Logic
Ask various people to define “programmer,” and you’ll likely receive many responses centered around “someone who writes code.” While technically accurate, this definition is incomplete. A programmer, software engineer, developer – whatever the title – is fundamentally a translator in a 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 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 team meeting, this statement might be intuitively understood by everyone. However, for a computer, it lacks crucial details. Which button? Which background? What shade of red? What happens if the button is pressed again?
To eliminate ambiguity, we can 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.”
In JavaScript, this translates to:
<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>Alt text: Javascript code snippet demonstrating how to change button background color on click event, highlighting the translation of a natural language instruction into precise code.
If you’re familiar with JavaScript and presented with this code, you could translate it back into a natural language sentence, perhaps similar to the refined instruction above.
This translation process is the essence of programming. It’s 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 generate the code I need?” The recurring answer is: “You need to learn how to communicate with it effectively.”
If interacting with AI tools to obtain accurate results consistently requires using a specific language, then we are essentially engaging in programming with natural language. This isn’t a novel concept; the advancement of LLMs has simply lowered the barrier to entry due to their enhanced comprehension and complexity.
Even if application development evolves into a process of typing prompts into tools like ChatGPT, the necessity of using a precise language to generate reliable and functional output means that, in essence, we are still programming.
In the current landscape, building an application with LLMs, given their limitations, often requires programmers to assemble and integrate various code segments. This process still constitutes programming, necessitating a foundational understanding of the generated code’s language and how to piece together the AI-provided components.
But consider a future where these complexities become trivial, where AI handles everything. Imagine simply stating, “Compile these assets and deploy them to example.com.” At that point, is there even a need for programming languages? Could AI become the intermediary layer between data and results, eliminating the programming step entirely?
This scenario leads us to the concept of Artificial General Intelligence (AGI).
AGI: A Paradigm Shift Beyond Programming
Let’s imagine a future where AI has reached such sophistication that human intervention in programming becomes almost unnecessary. You could have a prompt interface connected to an AI-managed database, allowing you to request any dashboard, dataset, or program functionality simply through natural language commands. What then?
If AI reaches a level of capability where it can completely automate programming, it likely signifies its ability to replace a vast spectrum of creative and knowledge-worker professions. This could trigger a global economic downturn as a significant portion – potentially over 60% – of the workforce becomes redundant.
At a minimum, societal structures would necessitate the implementation of Universal Basic Income (UBI). In a more radical scenario, it could lead to Fully Automated Luxury Communism (FALC).
This, of course, assumes the immediate and universal adoption of such advanced AI technology across all businesses. While companies constantly seek to maximize profits and efficiency, the business world often adapts to technological shifts at a slower pace than the tech sector anticipates.
Many organizations are only now adopting tools like Docker or frameworks like React. The enterprise world moves deliberately, and even if AI tools could perform 90% of a development team’s tasks in creating new products, maintaining legacy systems and intricate, interdependent software will still require human expertise for a considerable period, even after AI adoption.
The software engineering profession currently has hundreds of thousands of open positions in the US alone. Even if complete automation were available today, full adaptation would be a protracted process.
Wrapping Up: The Enduring Role of the Programmer
This article stemmed from a need to articulate 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 to become more effective. I encourage anyone considering or starting a career in programming to continue learning and leveraging the tools and techniques available.
I believe we are on the cusp of remarkable advancements in both AI and software development, making this an exciting time to be in the field. Based on the current trajectory, I firmly believe that programming is not a dying career.
While increased efficiency might lead to smaller development teams and a shift in company roles, the same technology will lower the barrier to entry for startups and smaller businesses, enabling them to launch innovative products and services that would have previously demanded far greater time and resources.
If my assessment proves wrong and programming becomes obsolete in a few years, then it has been a fascinating journey. In that case, you might find me in a woodland cabin, contentedly gardening and crafting cabinetry.
