From Vibe Coding to AI Engineering: A Complete Practical Guide to Codex and Claude Code

The Two Top AI Coding Tools: Codex and Claude Code

The two most powerful AI coding tools widely recognized today are OpenAI's Codex and Anthropic's Claude Code. Both have become standard equipment in the daily workflow of professional developers.

Technical Background: Codex was first released by OpenAI in 2021 as a standalone API—a code-specialized fine-tuned version of GPT-3—and was later deeply integrated into GitHub Copilot. In 2025, the new generation of Codex was reborn as an Agent, capable of autonomously executing multi-step programming tasks within a sandboxed environment. Anthropic's Claude Code, on the other hand, is built on the Claude 3.x model series, using a CLI tool as its core interaction method and emphasizing deep contextual understanding of entire code repositories. Both are essentially "code Agents" rather than mere completion tools. The difference lies in Claude Code's greater focus on terminal workflows, whereas Codex emphasizes integration with web interfaces and CI/CD.

Deeper Differences in Architectural Philosophy: At the architectural level, Codex adopts a cloud-based sandboxed isolation execution model, where each task runs in an independent container environment—naturally suited for CI/CD pipeline integration. Claude Code, by contrast, centers on a local CLI, directly operating on the user's file system and terminal, with a context window as large as 200K tokens, allowing it to load global information from a large code repository in one go. This difference in design philosophy reflects the two companies' differing understandings of "AI coding": OpenAI tends to cloud-ify and asynchronize programming tasks, making it better suited for long-running batch code generation; Anthropic bets on locally deeply integrated, real-time interactive development experiences, better suited for complex debugging scenarios that require continuous context awareness. Neither path is absolutely superior—each corresponds to different engineering scenario requirements.

Technical Evolution of Agent Capabilities: The shift from code completion to code Agents is underpinned by fundamental breakthroughs in reinforcement learning and tool use (Tool Use / Function Calling). Traditional code completion tools (like early Copilot) were essentially engineering applications of "next-token prediction," whereas the Agent paradigm means the model can not only generate code snippets but also proactively invoke external tools such as the file system, terminal commands, browsers, and database queries, forming a complete closed loop of "perceive-plan-execute-feedback." After GPT-4o, OpenAI substantially strengthened the stability of tool calling, while Anthropic extended the Agent boundary to the GUI level through Claude's "Computer Use" capability. This evolution has upgraded AI coding tools from an "assistive input method" to a true "digital development colleague," but has also introduced new security challenges—sandbox isolation and permission control have thus become core concerns for enterprise-level deployment.

According to the practical experience of veteran instructors, the key factor determining AI coding capability is not the tool itself, but the capability of the underlying large model connected to it—the model backend always ranks first.

Notably, due to strategic adjustments by Anthropic, Claude Code's latest models are currently restricted to the US region only, and the recovery process after an account is banned is cumbersome. This has led many domestic developers to switch to Codex, or to connect Claude Code to Chinese large model backends to lower usage barriers and costs.

Practical Choices Among Chinese Large Models

After testing several mainstream Chinese models, here is the overall ranking:

• Zhipu GLM: First tier, with the smoothest overall experience;
• DeepSeek: Extremely cost-effective, with low pricing;
• Kimi, MiniMax, Xiaomi MiMo, Alibaba Tongyi, Tencent Hunyuan: All can be flexibly connected as backends.

Code Capability Benchmarks for Chinese Large Models: To evaluate whether a large model is suitable as a programming backend, the industry typically references three types of benchmarks: HumanEval, MBPP (Mostly Basic Python Problems), and SWE-bench. HumanEval, released by OpenAI, contains 164 Python programming problems that assess basic code generation ability. SWE-bench is closer to real engineering scenarios, requiring models to fix bugs in code repositories based on real GitHub Issues—a significantly harder challenge. The DeepSeek-Coder series already performs close to GPT-4 level on SWE-bench, yet costs only a tenth or even less—this is precisely the technical foundation for its "extreme cost-effectiveness." Zhipu GLM-4 has natural advantages in understanding Chinese code comments and mixed Chinese-English requirement descriptions, making it better suited to domestic business scenarios.

Dynamic Benchmarks: A New Direction to Avoid Data Contamination: It's worth mentioning that traditional static benchmarks (like HumanEval) carry a "data contamination" risk—the model's training data may already include the test questions, leading to inflated scores. To address this, LiveCodeBench emerged in 2024, dynamically building test sets by continuously scraping newly released problems from competitive platforms like LeetCode and Codeforces, better reflecting the model's true generalization ability. MiniMax's performance in long-context code understanding and Zhipu GLM's low misinterpretation rate in the Chinese requirement-to-code chain are both more objectively reflected on this leaderboard. When choosing a model backend, beyond benchmark scores, you should also focus on two practical metrics: context window length (which affects whether it can understand large code repositories) and API response latency (which affects development fluency). The former determines whether the AI can "see the big picture" in a single conversation, while the latter directly determines the smoothness of the development experience.

The combination of "tool + flexible model backend" is precisely the core strategy by which enterprises currently achieve cost reduction and efficiency improvement in AI coding.

The Capability Boundaries of Vibe Coding

Vibe Coding originated overseas, with the core idea being: developers or product managers don't need to write code themselves—they just need to describe the requirements clearly, and AI tools can generate a complete code implementation.

Concept Origin: The term Vibe Coding was proposed by OpenAI co-founder Andrej Karpathy on social media in early 2025, originally described as "fully immersing yourself in the vibes, forgetting the code even exists, just describing what you want and letting AI implement it." This concept quickly sparked wide discussion in the developer community—some hailed it as a milestone in the democratization of programming, while other engineers pointed out its fundamental flaws in engineering rigor. The essence of Vibe Coding is using natural language as the primary programming interface, which lowers the technical barrier but also pushes the accumulation rate of technical debt to new heights.

The Exponential Risk of Technical Debt: The concept of Technical Debt was proposed by software engineer Ward Cunningham in 1992 to describe the "debt" incurred in code quality in pursuit of short-term development speed. Under the Vibe Coding paradigm, the accumulation rate of technical debt risks accelerating exponentially compared to traditional development: AI models tend to generate "code that runs" rather than "maintainable code," lacking any spontaneous awareness of engineering norms like design patterns, SOLID principles, and module decoupling. More critically, non-technical users often cannot identify architectural flaws in generated code, and problems only erupt collectively once the project scales up. A McKinsey report notes that on average about 40% of development time in software projects is consumed dealing with technical debt, and this proportion may exceed 70% in the later stages of Vibe Coding projects.

A Quantitative View of Technical Debt: Technical debt is not an abstract concept—static analysis tools like SonarQube quantify it as "person-hours required to fix." Code in Vibe Coding projects often collectively fails on three core metrics: high Cyclomatic Complexity (measuring the branching complexity of code), a persistently high Code Duplication Rate, and near-zero test coverage. The root cause is that AI tends toward "inline expansion" rather than abstract encapsulation—similar logic gets repeatedly generated and scattered throughout the codebase rather than distilled into reusable functions or modules. This means any single requirement change later requires synchronized modifications in multiple places, causing refactoring costs to rise exponentially. This is precisely why Vibe Coding is naturally suited to short-lifecycle, frequently iterated prototype validation, rather than enterprise-grade products requiring long-term maintenance.

But Vibe Coding has a clear ceiling. As projects scale up, the following problems are exposed one by one:

• Poor code maintainability: AI-generated code often lacks standardization, making subsequent maintenance difficult;
• Bug fixing falls into an infinite loop: Product managers without technical knowledge struggle to effectively direct the AI to locate and fix production issues;
• Only capable of supporting toy projects: Some bloggers hype "AI replacing programmers," but the results they showcase are mostly overseas mini-websites, pomodoro timers, and other minimally functional applications.

The conclusion is clear: Vibe Coding is suitable for quickly validating ideas and building demos, but for enterprise-grade projects that are business-complex, technically complex, and high-concurrency, relying on it alone won't work.

AI Engineering: The Correct Solution for Enterprise Projects

The answer to breaking through the Vibe Coding bottleneck is AI engineering. The hands-on course is designed in three progressive stages:

Stage One: Getting Started Quickly with Vibe Coding

Using the most direct approach, generate a toy-level e-commerce project in a few minutes to help beginners understand the basic workflow of AI coding.

Stage Two: Plan Mode

Both Claude Code and Codex have a built-in Plan Mode. When facing relatively complex requirements, first let the AI plan the solution before executing—producing projects that are more controllable and more complex than pure Vibe Coding.

The Cognitive Science Basis of Plan Mode: The effectiveness of Plan Mode in engineering practice aligns closely with research on "Chain of Thought" (CoT) in the AI field. A 2022 paper by Google Brain first systematically demonstrated that guiding large models to "reason before answering" can multiply the accuracy of complex tasks. Plan Mode is essentially the engineering externalization of CoT: it presents the model's intermediate reasoning steps to the developer for review, forming a "Human-in-the-Loop" supervision mechanism. This corresponds closely to the academic Tree of Thoughts and ReAct framework (alternating reasoning and action)—the latter has been proven to have significant advantages over directly generating answers in tasks like code debugging and multi-step planning.

Human-in-the-Loop: The Safety Valve for Irreversible Operations: Human-in-the-Loop (HITL) is a key paradigm in machine learning system design, referring to the introduction of human review at critical decision nodes in an automated process to balance efficiency and reliability. In the AI coding context, Plan Mode concretizes this mechanism as a "planning document review checkpoint": before executing code modifications, the model must first present the complete action plan to the developer in natural language, at which point the developer can correct course, add constraints, or reject execution. This is analogous to the aviation industry's "Two-Person Rule"—the more irreversible an operation, the more it requires a human review node. For engineers, the value of Plan Mode lies not only in improving code quality, but in transforming the AI's "black-box decisions" into "auditable planning documents," greatly reducing communication costs and rework risks for complex requirements.

Stage Three: Super Power Plugins and Spec-Driven Development

This is the true enterprise-grade solution. Super Power is a core plugin for Claude Code (Codex also has a corresponding implementation), essentially a complete AI engineering skill set covering dozens of Skills, spanning the full R&D pipeline of requirements → analysis → development → testing → deployment → launch.

This approach is consistent with SDD (Spec-Driven Development)—using specifications to constrain the entire development process, thereby ensuring code quality and maintainability.

Engineering Background: Spec-Driven Development is not a new invention of the AI era; its intellectual roots trace back to formal methods and Design by Contract. Design by Contract was proposed by Bertrand Meyer in 1986 alongside the Eiffel language, with the core idea of explicitly defining a component's behavioral contract at the code level through preconditions, postconditions, and invariants. In the AI coding context, SDD takes on new meaning: developers first write detailed functional specifications, interface contracts, and test cases in natural language or structured formats, then use the specification documents as context to drive AI code generation. The core value of this approach is anchoring the AI's "randomness" within deterministic specification boundaries, making the generated code auditable and maintainable. A relevant paper from the Microsoft Research team shows that high-quality specification input can increase AI code correctness by over 40%.

The Engineering Legacy of Formal Methods: SDD has a stricter practical form in the field of formal methods: Model Checking tools (such as TLA+) allow developers to precisely describe system specifications in mathematical language and automatically verify whether the implementation satisfies the specification. AWS engineers have publicly shared that they used TLA+ to discover a subtle concurrency bug in DynamoDB's distributed design—a bug that would have been completely undetectable in code review. In the AI coding era, this approach has been "dimensionally reduced and popularized": developers don't need to master formal languages; they simply write good specifications in structured natural language and let the AI take on the heavy transformation work "from specification to implementation." It's worth noting that SDD has a natural synergy with Test-Driven Development (TDD)—by writing specifications and test cases first, then letting the AI generate implementation code that passes the tests, you can transform the "uncertainty" of AI coding into "a deterministic engineering task with clear acceptance criteria." This is precisely the key methodological breakthrough for landing enterprise-grade AI coding.

Some small and medium-sized enterprises have already deployed this pipeline in production environments. It is understood that leading major companies like Alibaba are also internally promoting similar AI engineering systems, exploring automated self-iterating, self-evolving development closed loops.

Development Environment: Why VS Code Beats Traditional IDEs

Regarding tool selection, we clearly recommend using Microsoft's VS Code over traditional heavyweight IDEs like IntelliJ IDEA. The viewpoint is direct: in the AI era, if traditional IDEs don't undergo fundamental transformation, they may repeat the fate of Eclipse being replaced by IDEA within the next few years.

Overwhelming Market Share Advantage: According to the Stack Overflow 2024 Developer Survey, VS Code has topped the most popular IDE/editor list for 7 consecutive years with a 73.6% usage rate, far exceeding the second-place IntelliJ IDEA's 26%. More noteworthy is that VS Code's market share actually rose rather than fell during the AI tool explosion of 2023-2024, while the JetBrains series experienced a slight overall decline. By integrating VS Code, GitHub, Azure, and Copilot into a unified "developer cloud" ecosystem, Microsoft has built an integration advantage that single competitors find hard to replicate—this ecosystem lock-in effect is harder to disrupt than any single technical feature.

LSP Protocol: The Invisible Infrastructure Behind the AI Tool Explosion: The Language Server Protocol (LSP) was introduced by Microsoft alongside VS Code in 2016, with the original intent of decoupling the IDE's language intelligence features (code completion, go-to-definition, error checking, etc.) from the editor itself, running them as independent services. This architectural decision has shown remarkable foresight in the AI coding era: third-party AI tools (including Claude Code, Copilot competitors, etc.) can connect to VS Code at low cost through the standardized LSP interface, without deeply adapting to the editor kernel, greatly compressing the development cycle for new tools. In contrast, the plugin systems of Eclipse and early IntelliJ were highly coupled to the editor kernel, and every version upgrade could break plugin compatibility—an unbearable burden in today's era of daily AI tool iterations. Through LSP, Microsoft has effectively built a "standard slot" for AI coding tools, ensuring that no matter how AI technology evolves, VS Code is always the first platform to gain adaptation—this is its deepest moat in the AI era. The decline of Eclipse is a cautionary tale—once ecosystem transformation lags behind the market, share loss is often a cliff-like plunge.

The recommended environment configuration is as follows:

• Install the Claude Code plugin in VS Code to code directly through conversation within the editor;
• Pair it with Claude Code's CLI (command-line tool) and the Super Power plugin;
• Use Codex in both desktop and CLI forms.

The configuration itself is not complex—the core is simply connecting the model API (Claude, GPT, or a domestic model can be chosen), with the rest being essentially wizard-guided operations.

An Underrated Business Insight: Who Is Really Making Money in the AI Space?

Currently, consumer-facing AI applications (like Doubao, Yuanbao, etc.) are mostly in the money-burning phase. The players who are truly profitable are concentrated in the following three categories:

1. Compute and hardware: Demand for memory, chips, and semiconductors continues to climb, with obvious market performance;
2. Token sales: The token businesses of major companies like Zhipu and Tencent continue to grow;
3. Model aggregation platforms (API relay): Represented by OpenRouter, the world's largest AI model aggregation platform, which arbitrages by purchasing tokens cheaply and reselling them.

Analysis of OpenRouter's Business Model: OpenRouter was founded in 2023, with its core business model being the construction of a unified API gateway that aggregates the capabilities of dozens of model providers including OpenAI, Anthropic, Google, and Meta. Developers can access all models through a single interface and billing system. Its profit comes from adding roughly a 10%-20% premium on top of the raw token cost, while obtaining discounted prices through bulk purchasing. The barrier to this model lies not in the technology itself, but in: bargaining power from traffic scale, optimization of model routing algorithms (automatically selecting the most cost-effective model to handle a specific request), and the stickiness of the developer ecosystem. In 2024, OpenRouter announced that its monthly API call volume exceeded 10 billion, proving the scalability of this model. Domestic platforms like SiliconFlow are also replicating this path, further compressing costs through open-source model deployment.

The "Water and Shovels" Logic of the AI Infrastructure Layer: This business phenomenon has clear precedents in tech history. During the 19th-century American Gold Rush, those who truly profited stably were not the gold miners, but the basic suppliers selling shovels, jeans, and food—Levi Strauss got its start in this very context. In the current AI wave, compute providers (Nvidia, various cloud vendors), token distribution platforms (OpenRouter, SiliconFlow), and development toolchains (the VS Code ecosystem, API management platforms) play similar "shovel-selling" roles. The common feature of such infrastructure businesses is: they don't bet on which specific AI application will win, but instead provide the essential underlying resources for all participants, enjoying the dividends of the entire industry's growth. The combination of low technical barriers and high traffic moats makes model aggregation platforms one of the few business models in the AI era where "a small team can achieve large scale"—their core competitiveness lies not in code, but in channel relationships, traffic operations, and the continuous maintenance of a model evaluation system. From an investment and entrepreneurship perspective, before the competitive landscape at the application layer is settled, the infrastructure layer is often the track with the highest certainty and the best risk-adjusted returns.

It is understood that some overseas-focused teams specialize in such aggregation platforms, achieving annual revenues of one to two hundred million yuan; there are even single-person teams that achieved a scale of several hundred million within a year—the technical barrier is not high, but they precisely hit the core track of AI monetization. This is also the business logic behind the hands-on project "AI Model Aggregation Platform."

Conclusion: Mastering AI Engineering Is the Programmer's Core Competitiveness

From Vibe Coding to spec-driven engineering, AI coding is completing the key leap from "rapid prototyping" to "production-grade tools." For programmers, rather than being anxious about being replaced by AI, it's better to proactively master AI engineering methodologies—those who can effectively direct AI, locate complex bugs, and command enterprise-grade architectures will always be people who understand technology. Tools will eliminate those who cling to convention, and will also multiply the abilities of those who use them well.