From being overlooked to a fierce battle among giants, why has AI first set the programming world ablaze?

AI programming might be the largest native AI application field at present.

This sounds a bit counterintuitive because in the past few decades, "development tools" have never been the most profitable field in the software industry. However, everything has changed now.

This market is much larger than you might think.

There are approximately 30 million software developers globally. If each developer creates an economic value of $100,000 per year, the total output value of this group would be $3 trillion, almost equivalent to the GDP of France.

According to the results of the communication between the a16z team and dozens of technology companies, even the most basic AI coding assistants can currently improve development efficiency by 20%. Under ideal deployment, it is entirely possible to double the efficiency.

Behind the improvement of development efficiency is the re - evaluation of the entire software industry. The underlying logic is actually quite simple: the higher the development efficiency, the greater the total demand; the faster the development, the more software will be produced.

In other words, AI programming is expected to bring an additional $3 trillion in output value to the global economy, and this is just the beginning.

Today, AI programming not only supports a number of startups valued at billions of dollars but also has the potential to give rise to the next technology giant worth trillions of dollars. This is why more and more players are starting to flock to the AI programming field:

Cursor achieved an annual revenue of $500 million in just 15 months and is valued at nearly $10 billion; Google spent $2.4 billion to acquire Windsurf; Anthropic launched Claude Code; and OpenAI's GPT - 5 has also enhanced its programming capabilities.

It can be seen that the era of the "Warring States" in AI programming has fully begun. What will AI coding look like in the future? There is no definite answer yet, but the prototype is already emerging.

Recently, A16Z published an article on AI programming, systematically dissecting the structure of this emerging field: from the innovation of the toolchain to the changes in the collaboration mode, it showcases a future of software development that is being reshaped.

The Paradigm of Software Development Has Changed

In the past, when using AI to write code, the process was like this: you would first ask it, "Help me write a login interface," it would reply with a piece of code, and then you would copy and paste it into your project. This "order - style" coding method has gradually become outdated.

Now, a brand - new development paradigm is becoming popular, known as "Plan → Code → Review". Instead of humans asking questions and AI providing answers, AI participates throughout the entire process:

First, plan: AI is responsible for drafting a detailed functional description for you and actively asking for the information it needs, such as API keys, access permissions, and system dependencies.

Then, code: AI automatically generates code based on the plan and can even complete unit tests, forming a small "agent loop" in the process.

Finally, review: Human developers only need to check AI's work and make minor adjustments if necessary.

The chart shows how artificial intelligence decomposes high - level specifications and asks questions

This diagram shows a typical process when AI intervenes at the start of a new project. Its first task is to write a high - level functional specification. It will actively ask a series of questions, requesting to fill in all the background information it considers crucial.

These questions and requests often involve detailed requirements, architectural decisions, external dependencies, permission configurations, etc. It may even specifically ask you to provide API keys, tool access permissions, and other practical operating conditions. The final result is a multi - page, well - structured list of additional information.

This set of specification documents has two values. On the one hand, it can accurately guide subsequent code generation, ensuring that the content written by the model aligns with the development intention; on the other hand, it can also serve as the "long - term memory" of the entire project, helping developers or other models understand the functions of a certain module or file. Especially in large - scale projects, codebases are often very complex, and a clear specification is the anchor for maintaining order.

This process is not a one - time thing. After human developers modify the code, they usually ask the language model to go back and update the specification document, ensuring that this description always follows the latest state of the code. The final result is a set of "well - documented" engineering outputs, which are convenient for both humans to consult and AI to continue tasks, truly achieving a virtuous cycle in human - machine collaboration.

Picture of Cursor Directory, a coding guide library for LLMs

In addition to the requirements of each project itself, most current AI coding systems are also equipped with a set of general architectures and coding specifications. Some of these specifications cover the entire company, while others are specifically for a certain project or module, mainly used to constrain technical details such as code style, architecture selection, and interface design, making development work more rule - based.

More interestingly, there are also many "best practice collections" tailored for AI models on the Internet, such as Cursor's rule set, prompt templates shared in the GitHub community, and even development instructions related to Claude Code.

This type of content is not written for humans but specifically for AI models to read.

We are witnessing the emergence of a new type of knowledge base - it is no longer for training new employees but for making AI a real collaborative partner.

Under this new paradigm, AI is no longer just a tool that writes a piece of code when you say a word. Instead, it can be a "teammate" that participates in the entire product development process. It can understand the company's technical policies, master project backgrounds, and even be familiar with industry standards, with increasingly strong context comprehension ability. It is no longer just about executing commands but can participate in architectural design, functional planning, and even detect potential risks in advance.

In the project planning stage, although the role of AI is still in the early exploration phase, many companies are already trying to introduce it into more upstream processes.

For example, tools like Nexoro, which focus on information organization, can automatically extract customer feedback from Slack, forums, emails, and CRM systems (such as Salesforce and Hubspot), and summarize them into a list of "what users want".

Another type of tools, such as Delty and Traycer, focus more on the "task decomposition" step. They can automatically convert a functional description into executable user stories and then synchronize them to work order systems like Linear to assist the team in advancing development.

These trends send a very clear signal: The past way of relying on wiki documents and manually maintaining task trackers can no longer keep up with the fast - paced and complex project requirements of today.

Traditional tools are either gradually being phased out or need to be reconstructed by AI to become more intelligent, efficient, and automated. The collaboration mode of software development is being redefined.

From Writing Code to Becoming a Programming "Partner"

Once the preliminary planning is complete, the next step is to enter the "cyclic process" of AI coding: AI writes the code first, and then developers review and make minor adjustments. This process will be iterated continuously, and the specific interaction method depends on the complexity of the task and whether asynchronous execution is required.

The most common way is the "Tab completion" and "intelligent editing" functions. These functions have been seamlessly integrated into many modern code editors, such as Cursor, Windsurf, Sourcegraph Amp, and even various VSCode plugins.

As long as users write code normally in the editor, AI will automatically complete the current line based on the context or modify local content, almost without the need for manual triggering of prompts. These capabilities rely on specially optimized small models, which are lightweight and responsive, capable of providing quick local responses and improving development efficiency.

Another more flexible way is the "chat - based" file editing experience. Users can directly give instructions to AI, such as "Help me convert this function to asynchronous," while providing relevant context. AI will call large models with large context windows to globally understand the entire project folder and can even perform cross - file operations, such as creating new files and adding dependency packages.

This type of tool can be embedded in IDEs or used through web pages, with visual feedback at each step, making it convenient for users to quickly confirm the modification results.

To put it simply, AI coding is evolving from "writing a few lines of code" to "collaboratively completing the entire development task", and the interaction methods are becoming more diverse. There are both lightweight models with instant responses and large models with global understanding, allowing developers with different needs to find a suitable working mode.

AI agents running in the background are a bit different from ordinary AI assistants. They don't require constant human interaction and can work independently for a long time, automatically advancing tasks. These agents usually run tests on their own to ensure that the results are correct - after all, since the user is not on - site, the system must have a way to judge right from wrong on its own.

The final output of these AIs is often a modified code tree or a Pull Request (code merge request) ready to be submitted to the Git repository. Tools like Devin, Anthropic Code, and Cursor's background agents are representatives of this type of "silent - working" AI.

Meanwhile, another type of tool is also emerging rapidly, which are AI application builders and prototyping tools. Platforms such as Lovable, Bolt (under Stackblitz), Vercel v0, and Replit are trying to directly generate a whole runnable application using natural language, wireframes, or even simple UI examples, rather than just the front - end pages.

These tools are attracting two types of people: one type is entrepreneurs or designers who want to quickly create an MVP, and the other type is professional developers who want to use AI to quickly test and build prototypes. Although currently, few people directly use the UI code generated by AI in officially launched projects, this is more because the tools are still in the growth stage rather than the wrong direction.

In the future, when their stability is improved, AI may truly become a full - stack "partner" that can write UI, back - end code, connect databases, and access APIs. Perhaps the day when you can "generate an app with a single sentence" is not far away.

As AI agents play an increasingly important role in projects, the focus of developers has also shifted. In the past, we cared more about "how the code was modified"; now, the focus has become "why it was modified" and "whether the modification was effective". Especially when AI generates an entire file at once, the traditional "diff (difference) comparison" method is no longer as useful.

Therefore, some new tools are starting to redefine "version control". For example, Gitbutler no longer focuses on how each line of the file content changes but records the development process around "intent":

How does AI understand the requirements? What prompts were used? What was the test result? This information is more valuable than simple code differences. Git has become a "ledger system" in the background, and the truly meaningful operations occur at the "semantic layer" - that is, the trajectory of goals, decisions, and results.

Meanwhile, AI is also increasingly involved in source code management systems (such as GitHub) themselves. Currently, many teams are already letting AI participate in discussions about issues and pull requests. These discussion contents themselves are a kind of "context input", which can help AI better understand the development intention and thus provide more appropriate implementation solutions.

In the code review stage, AI is also starting to take on the role of a "reviewer". It focuses on the correctness, security, and compliance of the code, assisting developers in improving code quality. Tools like Graphite and CodeRabbit are representatives in this area, exploring a new development collaboration model of "AI reviewing AI".

Currently, the work processes of most AI coding assistants are highly automated. That is to say, they will independently decide what to do next and call various tools to complete tasks (referred to as "3 - star" capabilities in frameworks such as Hugging Face). For example, tasks such as minor text modifications, updating a library, or adding a simple function can now often be completely completed independently by AI without human intervention.

This trend has also brought some "highlight moments". For example, in an issue discussing a function on GitHub, the final comment was just "@aihelper, please implement it". A few minutes later, AI automatically generated an almost perfect pull request, which was directly merged and launched. Although such "stroke of genius" is not common at present, it is starting to become possible in simple scenarios.

In contrast, more complex development tasks still require human decision - making, but one area has been proven to be particularly suitable for AI, which is legacy code migration. This is one of the most mature and effective implementation scenarios for AI coding at present.

Common examples include migrating old languages such as Fortran or COBOL to Java, converting Perl to Python, or replacing outdated Java libraries. A typical approach is to first let AI extract functional specifications from the old code and then re - implement them in a new language based on these specifications. The old code is no longer directly copied and pasted but becomes a "control group" for resolving ambiguities.

The market potential in this area is very large, and many startups are already focusing on this field. Especially in industries such as finance and manufacturing that rely heavily on old systems, AI is becoming a super tool for "renovation projects", with much higher efficiency than traditional manual solutions.

Today, AI writing code is no longer just about "writing a few new functions". It is becoming a key player in the modernization and upgrading of large - scale systems.

Don't Just Focus on AI Writing Code; It Can Also Handle Testing and Documentation

Many people think that the process ends once AI finishes writing the code. However, the real "game - changer" is yet to come.

After the code is written, there are two key steps: testing and documentation generation. Now, both of these parts are being rewritten by AI.

Let's start with documentation. Current large models, such as GPT - 4 and Claude Opus, can already write very professional and well - structured technical documents. Moreover, they can not only write but also "use the documents".

What does this mean? For example, if you ask AI, "What does this function do?" It can not only answer but also retrieve comments, examples, and context code to explain it clearly to you, more reliable than an old employee.

Context7 specializes in this. It will automatically retrieve relevant content when you need it, ensuring that the documents written by AI are "grown out of the code" rather than high - sounding but irrelevant clichés.

Even more powerful is Mintlify. It can not only help you generate static documentation pages but also build a "documentation assistant". You can ask questions, search for usage, and even ask AI to regenerate a certain part of the documentation with a single sentence. It is especially suitable for product documentation for customers, far superior to PDFs.

In enterprises, there is also a more "serious" type of documentation called security and compliance documentation. In the past, this kind of thing was written by dedicated personnel, which was slow and error - prone. Now, with AI tools like Delve, they can directly generate and update it, making compliance no longer a troublesome process but part of automation.

Now, let's look at testing.

Writing test cases used to be really troublesome, especially for process tests across UI, API, and databases, which could easily reach hundreds of lines. Now, AI QA tools can handle it fully automatically. They can not only write test scripts but also run the processes themselves, check the results, output error reports, and even provide "suggested repair methods".

What does this mean? In the past, the development process was: "Write code → Manual review → Manual writing of tests → Submit for launch"; now, for some tasks, AI can handle everything from writing to testing and then submitting, only requiring your final approval.

Especially when more and more code generated by AI is becoming a "black box", we are more concerned about "whether it is wrong" rather than "whether we can understand it". At this time, the full - scale involvement of AI in testing, documentation, and compliance becomes particularly crucial.

The Fully Automated Toolchain Behind the Agent System

In addition to the tools for human developers, there is now a type of "toolchain"