跪拜 Guibai
← Back to the summary

AI Killed Syntax Drills. The New Developer Skill Is Judgment.

Hello everyone, I'm Shuangyue, author of wangEditor, former senior frontend engineer at Baidu and Didi, elite instructor at Imooc, PMP, and author of Frontend Interview Pai.

I am currently working on the development and upgrade of two projects. If you're interested, feel free to DM me to join the project group.

Getting Started

AI programming is rapidly spreading. Almost all developers are using AI to write code, and the efficiency gains are visible to the naked eye: work that used to take a day can now be done in half an hour, and writing thousands of lines of code a day is no longer news.

Against this backdrop, a question is being raised by more and more people: For programming beginners, is it still necessary to grind through basic syntax like variables, loops, and functions, bit by bit, as in the past?

Learning it is slow. Syntax itself doesn't have much technical depth; a lot of time is spent memorizing rules, debugging spelling errors, and understanding various 'why do I need a semicolon here' questions. The cost-effectiveness is very low, especially when AI can write correct code in seconds, making this investment seem even more inefficient.

Not learning it, however, is unsettling. You can't understand the code AI writes, you can't troubleshoot when bugs appear, and once the project gets slightly complex, you completely lose control, left only to pray that the AI doesn't make mistakes.

At first glance, this question seems to have no standard answer, but if you think about it from another angle—perhaps we are asking the wrong question. What's truly worth discussing is not 'should I learn syntax,' but 'in the era of AI programming, what is the core competency of a programmer.'

Tech Stack Knowledge System

I am a frontend developer, recently learning Java and Spring Boot. With the help of AI programming, I indeed don't need to obsess over syntax details: how to write generics, how to add annotations, the specific parameter order of an API—these can all be left to AI.

But at the same time, I find myself facing a higher-dimensional requirement: you must be familiar with the complete knowledge system of this tech stack.

This system can certainly be acquired through AI—you can ask it how a Spring Boot project should be organized, and it will explain it clearly. The problem is, if you haven't studied it yourself and aren't familiar with the domain, you simply won't understand what AI is telling you, let alone make judgments. It's like a person who has never learned a foreign language traveling abroad with a translation app; the app can translate every sentence for you, but you still can't grasp the subtext and cultural background in the other person's words.

Taking Java web server development as an example, the most basic server-side knowledge system roughly includes:

For a beginner, mastering this entire system is far more difficult and far more important than learning Java syntax itself. So rather than agonizing over 'should I learn syntax,' it's better to shift your thinking: start learning from these knowledge points that are closer to practical engineering and have a relatively lower dimension. Syntax will naturally be understood in the process of using AI programming.

What to Control in AI Programming

The topic of the tech stack knowledge system is too vast to be covered in a single article. Returning to programming itself, in the AI programming model, we don't need to, and it's not recommended to, manually type out code. But as a developer, there are several things you must personally control.

First, technology selection. What programming language, what framework, which tools and third-party services to rely on—these decisions directly determine the project's technical boundaries and future maintainability. AI can list the pros and cons of several options for you, but choosing which one and why is your responsibility.

Second, project architecture. How the code directory is organized, how modules are divided, how data structures are designed, how the system's scalability is reserved—these are the keys that determine whether a project can 'grow up.' A well-designed architecture makes adding features and changing requirements later easy; a poorly designed one quickly turns the code into a tangled mess, and no matter how fast AI writes, it can't save a bad architecture.

Third, acceptance criteria. When you ask AI to write code, you must clearly tell it what requirements to meet, what functions and business processes to satisfy, and absolutely not let it 'freestyle.' The more specific the requirement description and the clearer the boundary conditions, the more reliable the AI's delivery will be. Conversely, if you can't even articulate what you want yourself, then no matter how powerful the AI is, it can't help you.

For these three things, you can let AI participate in discussions and give suggestions, but the final decision-making power must remain in your own hands. This is actually a shift in the capability requirements for developers in the AI programming era: from 'can you write code' to 'can you make judgments.'

Making Good Use of Testing

Many people worry that the code written by AI hides vulnerabilities, so they think about reviewing every single line of code AI produces.

This approach is like being the head of a team who worries that subordinates are unreliable, and thus meticulously reviews every step and every action they take. With this mindset, wanting to do everything yourself, your team can never truly grow and strengthen—your energy is ultimately limited, and the method of manually reviewing code simply cannot keep pace with the efficiency of AI producing thousands of lines of code a day.

A more reliable approach is: you don't need to review every line of code AI writes, but instead have it write the tests properly, including unit tests and integration tests.

Specifically, you can stipulate that test cases must cover all functional points involved in the requirements, and require that after every code change, all unit tests must pass. You only need to control the design of the test cases and the business scenarios they cover, leaving the rest to the tests to verify—as long as the tests are genuine, comprehensive, and all pass, this method of quality assurance is actually much more reliable and faster than scanning the code with your own eyes.

In other words, in the AI programming era, testing is no longer just an 'icing on the cake' engineering standard, but the core mechanism for building trust between you and AI. The object of your scrutiny shifts from 'is the code written correctly' to 'is the test design comprehensive,' which is itself a capability upgrade.

Finally

After the popularization of AI programming, beginners no longer need to start from scratch grinding through basic syntax, nor do they need to review every line of code AI writes line by line—these two things, which were the foundation of a programmer's livelihood in the past, are having their importance re-evaluated today.

What is truly worth investing time in is doing a good job of technology selection, designing reasonable technical solutions, while having AI take on the writing of unit tests and integration tests, and clearly standardizing the acceptance criteria for AI programming. When these three things are done solidly, AI can truly become your productivity amplifier, not a black box that keeps you on edge.

As your work experience grows, you will gradually master the complete knowledge system of your tech stack—from frameworks to databases, from message queues to deployment and operations—this process itself is the path of advancement from 'knowing how to use AI to write code' to 'being able to command AI to do engineering.' When you reach this stage, you will still be an excellent programmer, it's just that your core competitiveness has shifted from 'proficiently typing code' to 'precisely making judgments.'