Unlock Rapid Development: How AI Programming Revolutionizes Your Coding Journey!

The Era of Sole Product Managers?
While many media outlets claim that we now live in an era where only product managers are needed to create good products/tools, my experience this week using Windsulf (averaging over 3 hours daily) suggests that it’s not quite that simple.

In short, when faced with a problem, AI might know three potential solutions: A, B, and C.

First, it suggests trying solution A. If that doesn’t work, it moves on to B, and if B fails, it suggests C. If one of these solutions works, that’s great. However, if none of these solutions are effective, you might find yourself back to A again (it feels similar to a boss asking you to revise a plan, only to revert to the first version in the end).

By this time, however, your code has already been significantly altered, and it may become impossible to revert back to the original state. You’re left with no choice but to force a rollback to the last stable version and start over.

The root of this issue lies in my complete reliance on the product management role, testing out lines of code without reviewing them, and continuously accepting Windsulf’s modifications, or simply saying, “Okay, no problem. Please continue.”

Similar attempts work well only for simple tasks, like using templates to create landing pages. If you’re using a multilingual template, though, the AI might end up creating duplicate configuration files.

For instance, if your project already has next.config.ts and i18n.ts, the AI might create another set during its operations. If you don’t correct this in a timely manner, the errors will start piling up, leading to increasing confusion.

Another experiment was letting AI create an H5 mini-game. The first version was surprisingly impressive, aside from its aesthetics; the core functionality was completed in a flash. However, it generated a game.js file with over 600 lines of code, and one of the modules contained at least a dozen functions.

This led to a common issue with Claude’s code generation: each time it generates code, the order of functions at the same level changes. For instance, the first generation might produce:

func A
func B
…
But the next generation could yield:

func C
func A
…
When Windsulf performs code replacement, it uses a method similar to GitHub’s file diff. Such order changes can cause some lines of code, which didn’t need deleting, to be wrongly removed.

Hence, when Windsulf is editing a particularly lengthy code file, it feels like playing whack-a-mole: one issue pops up, only for three more to appear. Given this situation, complex projects sometimes necessitate reverting back to a cursor for a semi-automated approach.

This reminded me of my previous attempt to have GPT fully automate an iOS project, which ultimately led me to learn Swift from scratch.

When you want to use AI to assist in programming, but the recommended tech stack is unfamiliar, you still need to take the time to familiarize yourself with the official documentation, at least to understand the basic architecture and principles of each technology.

Otherwise, during the process, the AI’s confident assurances, “This time should solve the XXX problem,” can easily lead you into pitfalls.

Changes in Programming in the AI Era
What new changes have emerged in programming in the AI era?

Before diving into the discussion, readers can quickly glance through the table of contents of the book C++ Primer:

Chapter 1: Getting Started 1
1.1 Writing a Simple C++ Program 2
1.2 Introduction to Input and Output 5
1.3 Overview of Comments 8
1.4 Control Flow 10
1.5 Introduction to Classes 17
1.6 Bookstore Program 21
Summary 23
Glossary 23
Part I: Basics of C++ 27
Chapter 2: Variables and Basic Types 29
2.1 Fundamental Built-in Types 30
2.2 Variables 38
2.3 Compound Types 45
2.4 const Specifier 53
2.5 Type Handling 60
2.6 Custom Data Structures 64
Summary 69
Glossary 69
Chapter 3: Strings, Vectors, and Arrays 73
3.1 Using Namespace Declarations 74
3.2 Standard Library Type string 75
3.3 Standard Library Type vector 86
3.4 Introduction to Iterators 95
3.5 Arrays 101
3.6 Multidimensional Arrays 112
Summary 117
Glossary 117
Chapter 4: Expressions 119
4.1 Basics 120
4.2 Arithmetic Operators 124
4.3 Logical and Relational Operators 126
4.4 Assignment Operators 129
4.5 Increment and Decrement Operators 131
4.6 Member Access Operators 133
4.7 Conditional Operators 134
4.8 Bitwise Operators 135
4.9 sizeof Operator 139
4.10 Comma Operator 140
4.11 Type Conversion 141
4.12 Operator Precedence Table 147
Summary 149
Glossary 149
Chapter 5: Statements 153
5.1 Simple Statements 154
5.2 Scope of Statements 155
5.3 Conditional Statements 156
5.4 Iteration Statements 165
5.5 Jump Statements 170
5.6 try Blocks and Exception Handling 172
Summary 178
Glossary 178
Chapter 6: Functions 181
6.1 Fundamentals of Functions 182
6.2 Parameter Passing 187
6.3 Return Types and return Statements 199
6.4 Function Overloading 206
6.5 Special Language Features 211
6.6 Function Matching 217
6.7 Function Pointers 221
Summary 225
Glossary 225
Chapter 7: Classes 227
7.1 Defining Abstract Data Types 228
7.2 Access Control and Encapsulation 240
7.3 Other Class Features 243
7.4 Scope of Classes 253
7.5 Constructors Revisited 257
7.6 Class Static Members 268
Summary 273
Glossary 273
Part II: The C++ Standard Library 275
Chapter 8: I/O Library 277
8.1 I/O Classes 278
8.2 File Input and Output 283
8.3 string Streams 287
Summary 290
Glossary 290
Chapter 9: Sequence Containers 291
9.1 Overview of Sequence Containers 292
9.2 Overview of Container Library 294
9.3 Operations on Sequence Containers 305
9.4 How vector Objects Grow 317
9.5 Additional string Operations 320
9.6 Container Adapters 329
Summary 332
Glossary 332
Chapter 10: Generic Algorithms 335
10.1 Overview 336
10.2 Introduction to Generic Algorithms 338
10.3 Custom Operations 344
10.4 Revisiting Iterators 357
10.5 Structure of Generic Algorithms 365
10.6 Container-Specific Algorithms 369
Summary 371
Glossary 371
Chapter 11: Associative Containers 373
11.1 Using Associative Containers 374
11.2 Overview of Associative Containers 376
11.3 Operations on Associative Containers 381
11.4 Unordered Containers 394
Summary 397
Glossary 397
Chapter 12: Dynamic Memory 399
12.1 Dynamic Memory and Smart Pointers 400
12.2 Dynamic Arrays 423
12.3 Using Standard Library: Text Query Program 430
Summary 436
Glossary 436
Part III: Tools for Class Designers 437
Chapter 13: Copy Control 439
13.1 Copying, Assignment, and Destruction 440
13.2 Copy Control and Resource Management 452
13.3 Swap Operations 457
13.4 Copy Control Examples 460
13.5 Dynamic Memory Management Classes 464
13.6 Object Moving 470
Summary 486
Glossary 486
Chapter 14: Operator Overloading and Type Conversion 489
14.1 Basic Concepts 490
14.2 Input and Output Operators 494
14.3 Arithmetic and Relational Operators 497
14.4 Assignment Operators 499
14.5 Subscript Operators 501
14.6 Increment and Decrement Operators 502
14.7 Member Access Operators 504
14.8 Function Call Operators 506
14.9 Overloading, Type Conversion, and Operators 514
Summary 523
Glossary 523
Chapter 15: Object-Oriented Programming 525
15.1 OOP: Overview 526
15.2 Defining Base and Derived Classes 527
15.3 Virtual Functions 536
15.4 Abstract Base Classes 540
15.5 Access Control and Inheritance 542
15.6 Class Scope in Inheritance 547
15.7 Constructors and Copy Control 551
15.8 Containers and Inheritance 558
15.9 Revisiting Text Query Program 562
Summary 575
Glossary 575
Chapter 16: Templates and Generic Programming 577
16.1 Defining Templates 578
16.2 Template Argument Deduction 600
16.3 Overloading and Templates 614
16.4 Variadic Templates 618
16.5 Template Specialization 624
Summary 630
Glossary 630
Part IV: Advanced Topics 633
Chapter 17: Special Facilities of the Standard Library 635
17.1 tuple Type 636
17.2 bitset Type 640
17.3 Regular Expressions 645
17.4 Random Numbers 659
17.5 Revisiting the I/O Library 666
Summary 680
Glossary 680
Chapter 18: Tools for Large Programs 683
18.1 Exception Handling 684
18.2 Namespaces 695
18.3 Multiple Inheritance and Virtual Inheritance 710
Summary 722
Glossary 722
Chapter 19: Special Tools and Techniques 725
19.1 Controlling Memory Allocation 726
19.2 Runtime Type Identification 730
19.3 Enumeration Types 736
19.4 Class Member Pointers 739
19.5 Nested Classes 746
19.6 union: A Space-Saving Class 749
19.7 Local Classes 754
19.8 Inherent Non-Portability Features 755
Even an excellent and authoritative textbook begins with explanations of variables and types, strings, and other data structures, before progressing to expressions, statements, and then to functions, classes, and libraries. Until Chapter 9, the content primarily covers the basics; only from Chapter 10 onwards do we get into advanced topics like generics, associative containers, and dynamic memory.

When faced with such a book, you might wonder:

How long will it take to learn a programming language and write your first application?

Reflecting on my college days, the amount of time spent genuinely listening in class was minimal for most students. Many only began to seriously search for tutorials and work hard when they knew a project (now referred to as the MVP) was due. During that time, it often felt like a lot was learned, and code didn’t need to be memorized. With practice, writing code became second nature.

In the realm of coding:

It’s increasingly difficult to succeed by specializing in just one language.
You might not need to memorize all aspects of every programming language.
You may even not need to write code by hand at all.
So, what matters more than the code itself? Instead, having a refined sense of taste in coding becomes essential.

For example, if you wanted to quickly build a mobile note-taking app, what steps would you take on the technical side of the project, aside from product design?

Choose a platform: Android/iOS/mini-program/H5…
Select an architecture: Monolithic/front-backend/cloud development…
Find references: GitHub/Gitee/GitBucket/GitLab…
Search for tutorials: YouTube/Bilibili/online searches…
Each aspect seems limited, but combined, they create a vast Cartesian product. If you have no foundational knowledge, the overwhelming choices regarding technology stacks like architecture, language, and frameworks can easily lead you to abandon the project.

In the AI era, the greatest advantage is that you can ask GPT these questions. If there’s an error, you can continually correct it, establishing a framework for action.

What is a Framework (Skeleton)?
Firstly, we need to clarify, before developing software, what the inputs are.

Undoubtedly, they start with requirements. But what do those requirements include?

Generally, the problems that requirements attempt to solve are:

Who are the users?
What problems do users expect to solve?
What potential experiences exist? How are these experiences ranked in terms of effectiveness, and which offers the best outcome?
Besides what users expect, what other possibilities exist?
These are generally the questions a product manager must consider. When these requirements are handed to a developer, they need to contemplate:

The software architecture: What architecture best suits these requirements?
Design patterns: How can one achieve the best possible scalability, robustness, and extensibility under the right architecture?
Feasibility: Is my current tech stack sufficient to create an MVP, and is the learning curve for any new technologies within an acceptable range?
The development timeline and cost: How can software development costs be estimated? After doubling the costs, what is the ROI, and how long will it take to complete the first version?
A framework is a system we need to clarify before we begin programming, post-requirement gathering. The system can be broken down from the ground up into: structure, function, and implementation. According to modern trends, this can be decomposed into system architecture, feature list, backend APIs, and frontend interfaces. This constitutes the framework originally applied in software development.

The Framework of AI Programming

In the era following the advances in AI programming capabilities, how will the above frameworks evolve?

Previously, a full-stack engineer was defined as someone proficient in both frontend and backend development and able to handle data. Now, a full-stack engineer can be better described as a product manager + project manager + technical manager + software architect + cross-functional AI full-stack individual.

An AI full-stack individual needs Standard Operating Procedures (SOPs) for each functional workflow, embedding these SOPs into design, development, and testing processes.

Skilled programmers have a toolbox filled with various handy tools. They do not write every line of code from scratch but rely on available code blocks or templates. For instance, some UI tools and frontend design systems break down commonly used features into reusable components, representing the core value of software: replicability, which can scale.

That joke about programmers only needing three keys (Ctrl, C, V) has some truth to it. But even so, programming remains a technical task; you still need to know what to copy and what to avoid. When developing with a familiar tech stack, the essence of AI programming frameworks lies in defining the constraints for AI inputs, similar to the previous toolbox model.

When faced with an unfamiliar tech stack, and once you’ve confirmed that it’s indeed necessary (for example, proving that a requirement only exists on iPhones), you must diligently study the iOS documentation, quick-start guides, and renowned community courses. The learning process can still involve AI assistance, such as helping to spot potential typos.

The learning journey isn’t solely for the purpose of hands-on coding; it revolves around how to effectively define constraints during development. While it shares similarities with the traditional toolbox model, it introduces added intelligent elements.

For example, you might first use GPT-01 to outline requirements and designs, generate prototypes using Bolt.new, establish the code structure, accomplish basic functionality with Windsurf, and then fine-tune using Cursor.

In my view, AI full-stack individuals, liberated from the burdens of traditional coding tasks, can now devote more time to focusing on requirements, business concerns, product design, and even marketing strategies.

Postscript
AI is not your hired hand; it’s unrealistic to expect AI to complete all your work.

If AI eventually becomes a mere tool for manual tasks, the joy of programming will cease to exist.

However,

AI can paint; does that mean artists will stop wielding their brushes?

AI can compose stories; does that mean writers will stop creating?

AI can write music; does that mean musicians will stop composing?

Absolutely not.

Creation is one of humanity’s deep-seated and highest-level aspirations.

As long as there are humans, creativity will continue — though AI will be a capable assistant in that journey.