With AI, “everybody is a programmer.” You do not need to learn syntax anymore. Just describe what you want, and the machine will write the code for you.
If you have spent any meaningful time in this profession, you are probably laughing right now. Or at least shaking your head.
This narrative has become extraordinarily popular. It appears in breathless LinkedIn posts, product marketing copy, and the excited proclamations of people who have just discovered that ChatGPT can generate a working Python script. And I understand the appeal. The idea that programming could become as simple as having a conversation is genuinely compelling. It democratizes access. It removes barriers. It sounds like progress.
But it fundamentally misunderstands what programming actually is, why code exists, and what happens after the initial script is generated. Let me explain why experienced engineers are skeptical, and why understanding syntax and language structure remains not just useful but essential.
The Persistent Fantasy of Eliminating Programmers
Before we examine the current AI moment, it is worth recognizing that we have been here before. Many times.
In the 1980s, CASE tools were supposed to make programming obsolete. Business analysts would draw diagrams, and working systems would emerge. In the 1990s, visual programming environments and RAD tools promised the same. The 2000s brought model-driven development. The 2010s gave us low-code and no-code platforms with identical promises.
Each generation of tools genuinely improved productivity for certain tasks. And each one failed to eliminate the need for people who deeply understand how software works. The pattern is consistent enough that it should prompt some skepticism when the same claims appear with new technology.
AI coding assistants are genuinely more capable than previous generations of automation tools. I use them daily, and they meaningfully accelerate certain types of work. But the fundamental dynamics have not changed as much as the marketing suggests.
The Core Misconception: Code as Machine Instructions
Here is the central error in the “no more syntax” argument: it assumes that code exists primarily to instruct computers.
It does not.
Code is a communication medium between humans. The fact that computers can execute it is almost a secondary consideration. If code were purely for machines, we would all write in assembly language or binary. We do not, because humans need to read, understand, modify, debug, and collaborate on code. The entire history of programming language evolution has been about making code more readable and maintainable by humans, not more efficient for machines.
Consider why we have:
- Variable names instead of memory addresses
- Functions and classes to organize logic
- Comments and documentation
- Coding conventions and style guides
- Code review processes
None of these exist for the computer’s benefit. They exist because other programmers, including your future self, need to understand what the code does and why.
When someone says “you do not need to understand syntax anymore,” they are essentially saying “you do not need to read.” That should immediately raise questions.
The Debugging Reality
Here is a scenario that every working programmer encounters regularly:
Your AI assistant generates 200 lines of code that looks correct. It handles the happy path beautifully. You deploy it, and three days later, a customer reports strange behavior. The logs show an edge case you did not anticipate. You need to figure out what is happening.
Now what?
If you cannot read the code, you cannot debug it. If you do not understand the language’s semantics, you cannot reason about why a particular sequence of operations produces unexpected results. If you have no mental model of how the runtime works, you cannot interpret error messages or stack traces.
You could ask the AI to fix it, certainly. But to do that effectively, you need to describe the problem accurately. And describing a software problem accurately requires understanding what the code is supposed to do versus what it actually does. Which requires reading and comprehending the code.
The people I know who use AI assistants most effectively are invariably strong programmers. They leverage AI to accelerate work they already understand. They can evaluate whether generated code is correct, identify subtle bugs, and recognize when the AI has made poor architectural decisions. They are not replaced by the tool; they are amplified by it.
What Syntax Actually Represents
Syntax is not arbitrary ceremony. It is compressed knowledge about how programs are structured and how they execute.
When you learn that a for loop has a particular structure, you are not just memorizing punctuation. You are learning about iteration, scope, initialization, and termination conditions. When you understand why some languages distinguish between equality and assignment operators, you are learning about expression evaluation and side effects. When you grasp how function parameters work, you are learning about calling conventions, stack frames, and data flow.
The syntax is the surface representation of these deeper concepts. Knowing the syntax means having instant access to these mental models when reading code. Not knowing it means being unable to engage with code at anything beyond a superficial level.
This is why experienced programmers can learn new languages quickly. The syntax is different, but the underlying concepts transfer. They are not memorizing arbitrary rules; they are recognizing patterns they have seen many times before in different disguises.
The Limits of Natural Language Specification
Advocates for prompt-based programming argue that we can specify what we want in natural language, avoiding the precision requirements of code syntax. This sounds reasonable until you try it for anything non-trivial.
Natural language is inherently ambiguous. That ambiguity is a feature for human communication, where context and shared understanding fill in gaps. It is a liability for programming, where precision determines correctness.
Consider: “Calculate the average of these numbers.” Simple enough. But: Should it be mean, median, or mode? What happens if the list is empty? What precision should the result have? Should null values be included or excluded? What if the numbers overflow during summation?
A working program must answer all these questions. Either you specify them in your prompt (at which point you are writing pseudo-code with extra steps), or you accept whatever the AI decides (at which point you have bugs you do not know about yet).
Professional software engineering is largely about handling these edge cases correctly. The happy path is usually straightforward. The complexity lives in error handling, boundary conditions, concurrency, security, and performance. These concerns do not disappear because you are specifying requirements in English instead of Python.
Reading Code You Did Not Write
Even if AI could generate perfect code from natural language specifications, professional programming would still require reading skills.
Most professional development involves working with existing codebases. You join a team, and there are hundreds of thousands of lines of code written by people who are no longer available to explain their decisions. You integrate with third-party libraries that have their own conventions and patterns. You debug production issues in systems you have never seen before.
The ability to read unfamiliar code, build a mental model of how it works, and reason about its behavior is fundamental to professional software work. AI assistants can help explain code, but using their explanations effectively still requires basic literacy in the language being explained.
Think of it this way: automatic translation services are remarkably good now. But that does not mean you should stop learning foreign languages if you plan to live in another country. Reading a menu translation is one thing. Understanding cultural nuances, catching errors, and communicating effectively requires actual language competence.
What AI Coding Assistants Actually Change
None of this means AI assistants are useless. They are genuinely valuable tools that change how we work. But the nature of that change is different from “nobody needs to know programming anymore.”
AI assistants excel at boilerplate generation, where the pattern is well-established and the context is clear. They are good at syntax lookup, remembering the exact method signature you need faster than searching documentation. They help with code transformation, converting between formats or refactoring when the requirements are precise. They are useful for exploration, quickly generating examples to learn from.
What they do not do well is understand your specific system’s constraints, business requirements, or architectural decisions. They cannot evaluate whether generated code fits your particular context. They struggle with novel problems that do not match training data patterns. They produce plausible-looking code that is subtly wrong in ways that require expertise to detect.
The correct mental model is not “AI replaces programmers” but “AI accelerates programmers.” The baseline competence required to use these tools effectively has not decreased. If anything, the ability to evaluate AI output requires broader knowledge than pure coding did before.
The Skills That Actually Matter More Now
Ironically, the rise of AI coding assistants makes certain traditional skills more important, not less.
Code review skills matter more because AI generates more code faster, and someone needs to evaluate it. Debugging skills matter more because you are working with code you did not write, often with subtle issues. Architectural thinking matters more because AI operates at the tactical level and humans must provide strategic direction. Understanding fundamentals matters more because AI mistakes often involve deep concepts that surface-level knowledge cannot detect.
The people who will struggle are those who could barely code before and now expect AI to handle everything. They will produce broken software faster than they did before, which is not an improvement.
The people who will thrive are strong engineers who use AI to multiply their capabilities while maintaining the judgment to guide it effectively. They write prompts that include necessary context because they understand what context matters. They recognize when generated code is wrong because they know what right looks like. They debug AI mistakes efficiently because they can read and reason about code.
A More Honest Framing
Here is what I think we can honestly say about AI and programming:
AI assistants are powerful tools that meaningfully increase programmer productivity for certain tasks. They lower the barrier to writing simple programs, which is genuinely good for accessibility. They change the nature of some programming work, shifting effort from writing to reviewing and integrating.
But they do not eliminate the need to understand how software works. They do not remove the requirement to read and comprehend code. They do not make syntax knowledge obsolete. They do not replace the judgment that comes from years of building and maintaining real systems.
If you want to use AI coding tools effectively, learn to program first. Understand the languages you work with. Build mental models of how systems behave. Develop the ability to read code critically and debug systematically. These skills are not made obsolete by AI; they are prerequisites for using AI well.
The “everybody is a programmer now” narrative makes for exciting headlines, but it does not match reality. Code remains a communication medium between humans, and reading remains a prerequisite for effective writing. That has not changed, regardless of how impressive the latest demos are.
Final Thoughts
I use AI coding assistants daily. They make me more productive. I recommend them to colleagues. And I remain convinced that deep knowledge of programming languages, syntax, and fundamentals is essential for anyone who wants to build professional software.
These are not contradictory positions. Tools extend capabilities; they do not replace understanding. A power saw makes a carpenter faster, but it does not teach them which joints to use or how to read blueprints.
If you are starting your programming journey, learn the fundamentals. Understand syntax. Build things from scratch. Struggle with debugging. Develop the reading skills that will serve you throughout your career. Then add AI assistants to your toolkit, and you will use them far more effectively than someone who skipped those foundations.
Code is for humans to read. That remains true regardless of who, or what, writes it.
What are your thoughts on AI and programming fundamentals? I would love to hear from engineers who use these tools daily. Connect with me on LinkedIn or follow me on Threads for more discussions on the practical realities of AI in software development.
If you found this perspective useful, consider exploring more articles on ivanturkovic.com where I write about software engineering, AI, and building technology with intention.