Prompting is Coding By Another Name
The rise of ChatGPT and other AI large language models (LLMs) in software development has led to sweeping and sometimes hyperbolic proclamations about the future of coding. Some technical leaders and executives argue that AI will eliminate the need for junior developers, while others suggest that coding itself is becoming obsolete. But if you've spent any significant time using LLMs for software development, you'll recognize a simple truth:
Writing prompts to generate code is just another form of coding.
The Shift from Writing Code to Validating Code
Traditional coding involves writing precise syntax in a “programming language” that a compiler or interpreter can execute. With LLMs, the process shifts—developers no longer directly write all of the code themselves but instead craft prompts that guide the model toward producing it. However, because the code generated by LLMs is "unsound"—meaning it can be (and at least for now often is) incorrect, inefficient, or inconsistent—the developer's role evolves from just writing code to validating its correctness, ensuring it meets requirements, and integrating it into a larger, perhaps legacy functional system.
In other words, the skillset of a software developer is not becoming obsolete; it is simply adapting. Instead of spending the majority of their time translating logic into syntax, developers increasingly spend their time reviewing, testing, and refining the output of LLMs. The ability to quickly spot inconsistencies, debug generated code, execute effective tests, and refine prompts to improve the result is becoming as critical as knowing how to write the code manually.
The Programming Language of Prompt Engineering
If you’ve watched software engineers try to incorporate AI into their daily software development processes, you may note that many of the most effective prompts for LLMs resemble structured shorthand rather than natural language. At a certain point, the structured patterns developers use start to look less like sentences and more like a form of coding themselves. These structured cues often include:
Technical directives (e.g., "Use Go concurrency primitives, no external libraries")
Structured formatting (e.g., bullet lists, numbered steps, or JSON-like structures)
Explicit constraints (e.g., "No recursion, only iteration")
This approach is not only more efficient to write but also results in more accurate AI-generated code. Engineers who master this shorthand can generate better results without needing to craft verbose explanations. In many ways, structured prompt engineering is evolving into a specialized syntax—one that increasingly blurs the lines between natural language and programming itself.
Junior Developers Aren't Going Anywhere
To be honest, I’ve never really liked the term "junior developer." If it means someone with less experience, then all developers are “junior” in some aspect at any given time—software technology changes too fast for anyone to be an expert in everything. And even the most experienced software developers need to always be learning.
However, in the context of the rise of AI, some argue that LLMs remove the need for less experienced engineers by handling boilerplate tasks. This is a seductive argument, especially for executives looking to cut costs to justify their large and thus far mostly low-ROI investments in AI hardware and software. (In a future post I’ll discuss where I think some of that ROI exists to be more readily found.) But saying junior developers are obsolete because of LLMs is like saying C eliminated the need for assembly programmers. Instead of reducing demand, higher-level abstractions tend to expand the scale of what we can build, increasing the overall need for developers of all skill levels.
Software engineering isn’t just about syntax; it’s about architecture, problem-solving, and understanding systems holistically. LLMs can assist in implementation, but they don’t replace the need for developers who deeply understand what’s being built and why.
Product Managers and End Users Aren’t Replacing Engineers
Another flawed assumption is that business users or product managers can bypass developers entirely by simply prompting an AI to generate code for them. While LLM-based AI can produce functional code snippets from natural language descriptions, there's a critical problem:
End users and product managers are notoriously bad at writing clear requirements.
Historically, the software industry acknowledged this issue by employing systems analysts—professionals whose job was to translate business needs into well-defined technical requirements. Over time, this role faded as organizations moved toward combined developer-analyst roles (often misclassified under the "DevOps" umbrella). However, the need for clear requirements never disappeared; it simply got absorbed into the responsibilities of developers.
The idea that non-technical users will be able to replace programmers by feeding raw requirements into LLMs misunderstands both the limitations of AI and the challenges of software development. If anything, the rise of LLMs may signal a need to reinvest in clearer requirements gathering and structured system analysis, rather than assuming AI can fill that gap.
From Syntax to Systems Thinking
Prompting is just another form of coding—one that shifts the focus from writing syntax to designing systems. Just as higher-level languages abstracted away low-level memory management, LLMs abstract parts of the coding process, allowing engineers to focus more on architecture, correctness, and efficiency.
The challenge isn’t just writing prompts but understanding how AI-generated code fits into a broader system. Effective software development today requires structuring inputs to maximize quality and reliability while validating outputs for correctness. Rather than replacing engineers, LLMs enable them to operate at a higher level—thinking in terms of systems, not just syntax.
The future of software engineering isn’t just about writing code—it’s about guiding AI to do it well. If you’re looking to refine your team’s approach to AI-assisted development, let’s connect.
