An In-Depth Analysis: Can Ordinary People Really Write Useful Code with AI?

If you are a programming novice who has never written formal code, you might want to try using AI to help you. However, the internet is full of claims like: "AI programming is for professionals; beginners can't build usable projects."

Consequently, when you hit a bottleneck and the AI fails to produce good code, you start to doubt yourself.

But is that really the case? Are you truly unable to master AI programming?

This article will break the mental shackles of the idea that "ordinary people cannot use AI programming effectively." It will show you the upper limits of what an average person can achieve with AI programming and the direction your efforts should take.

This post contains detailed analysis and logical derivation. If you are ready, let's begin.

Defining the Problem

The question "Can ordinary people use AI to write useful code?" is actually an invalid question because two of its core concepts are ambiguous.

• What does "ordinary person" mean? Does it refer to someone who knows absolutely nothing about code, or someone who has learned a bit but cannot write fluently?
• What is "useful code"? Does it have to be a corporate-level project? Does writing something for personal entertainment count?

Therefore, a large amount of online discussion, arguing, and opinion-sharing is essentially useless. When the problem itself isn't clearly defined, the discussion is just people talking past each other.

Let's redefine the problem clearly.

What is an Ordinary Person

Let's categorize people into three groups based on their programming ability:

• Novice: Has never learned or understood programming. Characteristics include not knowing how to use the command line or how to configure environments.
• Beginner: Has self-studied programming and can write simple programs, or has written projects in the past but has become rusty.
• Professional: Meets at least one of three criteria: has a computer science degree, graduated from a coding bootcamp, or has actual experience writing projects in a professional setting.

Note that while the gap between a novice and a beginner may seem small, it manifests as a significant divide when using AI for programming. A novice who doesn't understand the command line likely won't know how to use Claude Code, and someone who cannot configure an environment might generate code but be unable to run it.

Of course, the professional category can be further subdivided, but that is outside the scope of this article.

What is Useful Code

There are a thousand versions of "useful code" for a thousand different people. Because everyone's scenarios and goals are different, we cannot generalize.

However, when we discuss whether code is "useful," the underlying goal is usually to discuss whether the code is "maintainable."

If code is for one-time use (such as generating a schematic diagram), we don't need to worry about whether it's useful in the long term; it just needs to happen to produce a usable result once. When we discuss whether code is useful, we expect it to "stay useful"—meaning that during subsequent second or third rounds of modifications or when adding features, the code continues to work correctly.

Thus, we have clarified the definition of the problem:

For people with "novice" or "beginner" programming abilities, can they use AI to write "maintainable" projects?

Classification of AI Programming Products

If we carefully study the AI programming products on the market, we find that they have branched into products with different entry barriers targeting "novices," "beginners," and "professionals."

AI programming products can also be divided into three categories:

Category 1: Text-to-Code, represented by products like Lovable, v0, and Bolt.new.

These products have the lowest barrier to entry. You only need to describe your idea simply to generate a runnable application. Users don't need to worry about the code or the execution environment at all. However, these products are generally used for one-time code, such as product prototypes or MVPs.

Category 2: Programming Agents, represented by products like Codex, Claude Code, and Cursor.

These products are currently the most popular. Their primary role is to help you automatically generate code. If you wish, you can direct the AI to write all the code without writing a single line yourself. However, after the code is written, you still need to manually deploy and run it, so you still need to know how to configure environments.

Category 3: Traditional IDEs, represented by products like VS Code and Cursor.

This category is unrelated to AI in its original form. Before the emergence of Large Language Models (LLMs), only this type of product was available for programming, which is why programming was exclusively for professionals.

Notice that Cursor appears in both the second and third categories. This is because Cursor combines a traditional IDE with a programming agent, providing users with the capabilities of both.

Let's summarize these three types of AI programming products with a diagram:

It is important to note that these three categories are classified by entry barrier, not by the strength of the tool. Text-to-code products might be the most powerful in terms of capability, but to accommodate novice users, they often cannot handle overly complex projects.

The entry barriers of these three types of products correspond to the ability levels of the three groups of people. Here is a table to visualize this relationship:

Can Ordinary People Write Useful Code

With the above classification, we can derive a preliminary conclusion.

Let's revisit our problem definition: For people with "novice" or "beginner" programming abilities, can they use AI to write "maintainable" projects?

Looking at the scenarios for the three types of AI programming products, we can see that "Text-to-Code" products are mainly used for one-time code, so they don't count as maintainable projects. However, "Programming Agent" products can indeed be used to write maintainable projects.

For the "novice" group, they can only reach the threshold of "Text-to-Code" tools, making it difficult for them to write maintainable projects.

For the "beginner" group, they can use "Programming Agent" tools, which are capable of writing simple, maintainable projects.

At this point, we can answer the original question: Can ordinary people use AI to write useful code? The answer is: Yes. As long as you reach the "beginner" level, you can write useful, simple projects.

However, answering just like that would be a bit too thin. How simple is a "simple project"? Can it achieve my goals?

In my experience, if you have just reached the "beginner" threshold, given current model capabilities, the projects you can maintain are roughly: frontend-focused projects with a simple backend, no database, and page functions that aren't too complex. For example, an online resume website to showcase your personal work, or a web-based tool to help you record daily to-do items.

How can you build more complex and interesting projects? Please read on.

How to Maintain More Complex Projects

Let's introduce the concept of "Project Complexity" and use a chart to show the complexity of projects that people with different abilities can handle:

From the chart, we can see that different types of AI programming products have different entry barriers. The "Programming Agent" curve starts at the beginner level, while the "Traditional IDE" curve starts at the professional level. Tools with a higher entry barrier clearly have greater potential, supporting increasingly higher project complexity compared to the previous type of tool.

With this chart, the direction of our efforts becomes clear.

For a "novice," your only goal is to cross the threshold into the "beginner" category. Once you reach this level, you can use Programming Agent tools and find it much easier to write maintainable projects.

For a "beginner," your goal is to continuously move your ability to the right. In this process, you will be better able to direct AI to write code and handle more complex projects.

The good news is that this improvement in ability is not like the traditional way of learning, where you start with the syntax of a programming language and go through a very tedious process.

We can completely delegate the basic syntax of programming languages to the AI, thereby skipping the steep learning curve and directly learning the basic logic of directing AI programming.

Just as upgrading from "novice" to "beginner" isn't about mastering a programming language, but about learning to use the command line, learning to configure environments, and learning how to deploy and run projects.

The improvement of a "beginner's" ability can be reflected in the following points:

• Learning to choose the right tech stack. For example, asking AI to use React and Tailwind CSS for frontend code will result in a much more maintainable project than letting it write raw HTML + CSS + JavaScript.
• Understanding the division of labor between frontend, backend, and databases to better discuss project design with the AI.
• Understanding the principles behind AI programming tools to better direct the AI's work.

As your abilities improve, the capabilities of the models will also advance. By combining your strengths, you will be able to produce higher-quality code.

Summary

Let's return to the original question: Can ordinary people really use AI to write useful code? I believe that after reading this article, you have found an affirmative answer and a direction for your own efforts.

In the AI era, the way we learn programming is being disrupted. If you search for programming tutorials online, you might still see various "Introduction to Programming Language Syntax." These have caused countless people to give up before they even started, barring them from the world of programming.

Fortunately, in the AI era, we have different ways to learn programming. If you are an ordinary person who just wants to write your own projects, you can bypass tedious syntax learning and directly start directing AI programming, learning only the most critical knowledge points. Compared to before, you can achieve significant results with extremely low learning costs.

Of course, what specific content "novices" and "beginners" should learn and what projects they should practice remains an open question. I am also exploring the answer to this. In subsequent articles, I will share specific techniques and roadmaps.