In the ever-evolving tech landscape, opinions on the future of programming as a career are sharply divided, especially with the rapid advancements in Artificial Intelligence (AI). On social media, you’ll find two dominant perspectives. One suggests that programming is becoming obsolete, predicting that AI will soon replace human coders entirely. The other dismisses AI tools like ChatGPT and LLaMA as mere novelties, offering little real value to software development.
However, the reality is far more complex. These extreme viewpoints can be unsettling, particularly for those new to or considering a career in software engineering. This article aims to explore the nuanced impact of AI on programming in the coming years, offering a balanced perspective on what these changes might entail.
For a quick overview, here are the key takeaways:
- AI is expected to continue its advancement, likely following an S-curve pattern, although our current position on that curve remains uncertain.
- Large Language Models (LLMs) are unlikely to eliminate software engineering jobs. Instead, they are poised to enhance the efficiency of both teams and individual developers, enabling greater output with fewer resources and time.
- Tools like ChatGPT necessitate detailed, logical instructions to generate effective code. This process essentially mirrors the role of a programmer, albeit using a novel form of language.
- Should AI reach a point where human involvement in software creation becomes entirely unnecessary, we would likely have achieved Artificial General Intelligence (AGI). At that stage, the implications extend far beyond just programming careers, raising significant societal challenges.
Intrigued? Let’s delve deeper into these points.
AI Improvement and the S-Curve of Technological Advancement
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 based on text, images, and speech, exemplified by platforms like Midjourney. OpenAI’s enhancements to the GPT model have demonstrated impressive capabilities in generating both text and code. Furthermore, experiments with AutoGPT showcase the potential of developers using LLM entities to autonomously execute complex, multi-step tasks.
These advancements might suggest an exponential growth rate in AI development. However, technological progress often follows a pattern known as successive S-curves.
Historically, a new technology experiences a period of slow initial growth, followed by rapid acceleration, and eventually plateaus as it matures. Subsequent iterations of the technology then restart this cycle at a higher performance level. Viewed broadly, this progression can appear linear, but it is actually composed of multiple S-curve cycles.
It’s reasonable to assume that AI’s development trajectory will, at least for now, align with this S-curve model. The critical question then becomes: where are we currently situated on this curve? Are we at the cusp of exponential growth, or nearing a plateau with limited immediate advancements?
If I were to speculate, I would suggest we are approaching a plateau.
While LLMs and related AI technologies still have room for improvement in the short term, a significant breakthrough might be needed to propel us to the next phase of exponential growth.
As AI-generated content—be it video, audio, code, or images—becomes more prevalent, so too does the public’s ability to discern its artificial nature, often described as the “uncanny valley” effect. Like many complex projects, achieving the final 10% of truly seamless integration and perfection may require 90% of the total effort and time.
The timeline for reaching this next S-curve, and the subsequent surge in AI capabilities, remains uncertain and is a question that defies definitive answers.
LLMs: The Next Evolution in Integrated Development Environments (IDEs)
Focusing back on programming, the integration and refinement of models like OpenAI’s GPT in the coding sphere have been significant. Tools such as ChatGPT, GitHub Copilot, and the newer Copilot X are demonstrably enhancing developer productivity worldwide.
However, it’s crucial to recognize that these AI tools are not replacements for programmers; rather, they are sophisticated instruments in a developer’s toolkit, designed to improve workflow and output quality.
My personal experience transitioning from a basic text editor like Sublime Text to a comprehensive JetBrains IDE was transformative. My efficiency dramatically increased with features like autocompletion, automated refactoring, integrated testing, and enhanced dependency management. These IDE functionalities allowed me to produce cleaner, more robust code at a significantly accelerated pace.
AI-powered coding tools represent the next logical step in this progression of developer environment enhancement.
Since incorporating Copilot and ChatGPT into my personal projects at the beginning of this year, I’ve observed a similar boost in productivity.
Many tasks in new projects, while not intellectually demanding, are time-consuming. These include writing unit tests, generating frontend templates, creating new classes, or standardizing data outputs. With AI assistance, I can now accomplish these tasks up to ten times faster. These tools exhibit a remarkable ability to “understand” my intentions and generate the necessary code scaffolding within my projects.
Furthermore, when faced with complex function implementations or unfamiliar libraries, I’ve found AI to be invaluable. By simply typing a descriptive comment outlining the function I need, the AI typically generates a code block that closely meets my requirements.
For instance, while working on a PHP application and needing to use the FFMpeg library—known for its complex documentation—I simply wrote the following 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 functional code, requiring only minor adjustments for full integration.
The key benefit here is significant time savings. Even with prior in-depth knowledge of the FFMpeg library, the time saved might only be a minute or two. However, in situations where I have general language proficiency but lack specific library expertise, AI tools bridge this gap. I can articulate my needs and receive immediately usable code, bypassing the need for extensive documentation review, Stack Overflow searches, or iterative trial-and-error.
This is where the true power of AI in programming emerges: it empowers developers to work more effectively and efficiently.
However, two important caveats are worth noting:
- Overconfidence and Hallucinations: AI tools can sometimes exhibit overconfidence, generating code with arguments or functions that don’t actually exist within the project or specified libraries. While often correctable with minor adjustments or retries, occasionally, the AI can produce code that completely misses the mark. Fortunately, these instances are relatively infrequent.
- Lack of Contextual Awareness: Tools like ChatGPT and Copilot excel at creating code snippets for specific functions based on given inputs. However, building a complete application remains a more complex undertaking. Current limitations include text token limits (even advanced models like GPT-4 have constraints, around 8K tokens or approximately 6,000 words). Furthermore, even with vector databases and AutoGPT, maintaining a consistent development style and achieving overarching project goals in programs of moderate to high complexity remains challenging. While AI can readily create a functional to-do app, a more intricate system like a CRM for a barbershop is likely to result in incomplete functionality or ineffective code.
This point leads us directly to the next critical understanding of the programmer’s role.
Programmers: Translators in the Language of Logic
Ask various people to define “programmer,” and you’ll likely get many responses centered around “someone who writes code.” While technically accurate, this definition is incomplete. A programmer, software engineer, or developer 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 structured 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, fellow humans would likely grasp the intended meaning intuitively.
However, a computer requires far more detail. Which button? Which background? What shade of red? What happens if the button is pressed again?
To remove ambiguity, we must refine the instruction: “When the button with the ID ‘clicky’ is pressed, change the background of that same button to the color with the hex 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>If you understand JavaScript and were given this code, you could translate it back into a sentence similar to the more detailed instruction above.
This act of translation—between human intention and computer logic—is the essence of programming. It’s a primary reason why I believe programming will remain a relevant profession, even with increasingly sophisticated AI tools.
Countless online discussions revolve around the question, “Why isn’t ChatGPT producing the code I want?” The consistent answer boils down to:
“You need to learn how to communicate with it effectively.”
If interacting with an AI tool to get reliable results requires using a specific language, then we are essentially engaging in programming with natural language. This isn’t a novel concept, but the accessibility and sophistication of LLMs have significantly lowered the entry barrier.
Even if application development evolves into simply typing prompts into a tool like ChatGPT, the necessity of using a precise language to ensure consistent and functional output means the fundamental act of programming persists.
In the current landscape, attempting to build a complete application using LLMs often requires manual assembly and integration of AI-generated code snippets. This still constitutes programming, demanding foundational knowledge of the programming languages involved and the architecture to piece components together.
But what if AI advances to a point where these manual steps become trivial or unnecessary? Imagine instructing an AI, “Compile these assets and deploy them to example.com.” In such a scenario, does the concept of a programming language itself become obsolete? Could AI become the intermediary, directly translating our intent into functional results, bypassing the traditional coding step?
This brings us to the concept of Artificial General Intelligence (AGI).
The AGI Scenario: Widespread Disruption
Let’s consider the hypothetical scenario where AI reaches a level of proficiency that eliminates the need for human intervention in programming. Imagine a prompt-driven system connected to an AI-managed database, capable of generating any dashboard, dataset, or software functionality simply upon request. What would be the broader implications?
If AI becomes capable of automating programming to this extent, it would likely also be capable of replacing a vast spectrum of creative and knowledge-based professions. This could trigger a global economic downturn, as over 60% of the workforce might become redundant.
At a minimum, such a shift would necessitate Universal Basic Income (UBI). In a more extreme scenario, it could potentially lead to Fully Automated Luxury Communism (FALC).
Of course, this assumes that every business, across all sectors, would immediately adopt this technology. While companies are generally driven to maximize profit and efficiency, the business world often adapts at a slower pace than technological advancements might suggest.
Many organizations are only now adopting technologies like Docker or frameworks like React. The enterprise sector, in particular, is known for its deliberate pace. Even if AI tools could perform 90% of a development team’s tasks in new product creation, maintaining legacy systems and complex, interconnected infrastructures would still require human expertise, both during and after the integration of AI systems.
The software engineering profession currently has approximately 100,000 open positions in the US alone. Even if complete automation were to become available today, widespread adoption and integration would take considerable time.
In Conclusion: Programming Remains a Dynamic Career Path
This article has served as an exploration of my own reflections on AI and its implications for the programming profession. As someone who experiences anxiety, I admit to feeling some uncertainty about the future of software engineering.
However, I am also genuinely excited about the potential of AI tools to enhance productivity and enable me to become a more effective programmer. I encourage anyone interested in or currently pursuing a career in this field to continue learning and leverage the evolving tools and techniques available.
I believe we are on the cusp of exciting advancements in both AI and software development in the coming years. It remains a dynamic and engaging time to be in this profession. Based on the current trajectory, I firmly believe that a career in programming is far from being a dead end.
While increased efficiency may lead to smaller development teams and shifts in company roles, the same technologies that drive this efficiency also lower the barrier to entry for new ventures. Startups and smaller businesses can leverage these advancements to launch innovative products and services that would have previously required significantly more time and resources.
If my assessment proves incorrect, and programming becomes obsolete in the near future, then it has been a rewarding journey. You might then find me in a cabin in the woods, contentedly gardening and crafting cabinetry.
