There's a topic I want to talk about: in an era where AI is moving this fast, how should we learn to build software?

My earliest impression of programming was in middle school. I started with C. I was genuinely interested in programming then, and really curious how games and software actually got made. My idea at the time was to pick a language that was common and standard. I searched Baidu, and the answer I got was C. So I downloaded Visual Studio, bought a copy of C Primer Plus (6th edition), and started working through it. That's how I slowly learned what headers, variables, functions, types, and the rest of it were.

That was my first stage.

The second stage was learning from videos. I found learning from books painfully inefficient: first, you can't stuff a book into the computer, so you keep looking down at the page and looking up to type, which is painfully slow; second, a book is only a visual medium, while a video course has both sound and picture, so you take in information much faster. When I first learned Python on Bilibili, for example, it was from a programmer whose name was 小甲鱼, or something like that — how to request data in Python, how to write a web crawler, and so on. I barely use Python now and have mostly forgotten it, but that was definitely my second stage.

Then in 2022 ChatGPT launched, large language models entered people's field of view for the first time, and I started to realize that this thing really had endless potential.

Back then GPT-3 was still fairly limited. It was hard to use it for anything serious. The code it generated would often invent functions or types out of thin air. TypeScript was especially bad — maybe 5 errors in 10 lines. At the time it was basically unusable. Nobody expected AI to move this fast.

The first idea everyone had was: if AI can write code, let it help me write code. The Cursor team was the first to really get this. They put AI into their Cursor IDE: file tree on the left, code editor in the middle, and an AI chat pane on the right (there was no concept of an Agent yet). They packed the project tree, the current view, the file being edited, line numbers, and the specific functions into context and sent that to the AI, so the model had a rough grasp of the whole situation. When something went wrong — say a function failed on a network request and you couldn't catch the error — the AI could change the code with that context in mind.

The idea was genuinely ahead of its time, but compared with the engineers at Anthropic it was still conservative. Anthropic's engineers were much more aggressive: if large language models are getting this fast and this capable, is it possible that in the future we won't need to read a single line of code, or write a single line of code, and can hand the whole thing to AI?

So they built a tool called Claude Code.

I started using Claude Code the moment it launched. Until then I had only ever subscribed to ChatGPT Plus; I had never subscribed to Claude Pro. After Claude Code came out, everyone's timeline on X was talking about how powerful it was — spinning up a project from scratch, a personal site, even a C application, and so on.

Looking back now, the model at the time (Claude 3.0 Sonnet) was still fairly weak, but it really did shock people. I think that was a starting point for AI models: before, AI could only chat; now it could actually get work done. That was a huge change.

Which brings me to my third stage of learning to build software: using an Agent to help me learn.

You might have a question here: is this AI stuff actually reliable? It can write code, sure, but using it to learn feels like a much more serious matter. If you're just chatting — asking it to write a small app or a personal site — a mistake is just a mistake, no real harm. If you try to learn from it, doesn't the risk jump overnight?

People imagine a scene like this: I want to learn a new framework (React, say) and ask the AI to explain what useMemo and useEffect are. The AI lectures on with total confidence, and it turns out to be wrong, and I have no idea. I absorb the wrong explanation and use the wrong code. In the extreme case the wrong code even runs, and just plants a latent bug.

I think that worry is largely unnecessary, because we underestimate what large language models can do. My own sense is that from Claude Opus 4.5 onward, and from GPT 5.4 onward, their accuracy at programming and explaining is extremely high — even a real teacher in front of you might not be that accurate. People always think the model will get it wrong, but humans get it wrong far more often than machines do.

Today, it's hard to find a reason not to learn with AI. Learning with AI is a very AI-native way of doing things: you fold AI in from the ground up.

In the past we learned in relatively rigid ways — watching videos, reading books. In the future we will inevitably write code with AI. Before you even state a requirement, you let the AI clean the workspace and open a feature branch; after it writes the code, you accept the work or review the source. As models keep improving, we may not even review the source or the tests ourselves — we can just hand the tests to the Agent.

The transition between clumsily learning knowledge by hand and developing with an Agent (AI Coding) matters a lot. My view is blunt: in a time when AI is moving this fast, refusing to use AI at all and "hand-crafting" everything like some old-school artisan is completely pointless.

Some people think you learn more solidly without AI. That's the wrong idea. It's like a kid who only ever does arithmetic on an abacus. After the calculator is invented, he decides the calculator skips the essence, that it's a detour, so he sticks with the abacus. By the time he has mastered the abacus, he finds other people with calculators are doing more than ten times as much, and much faster. That's just wasted effort.

So AI learning is not merely a method. It is the new paradigm for learning to build software in the future — and for learning in any general field.