Vibe Coding in Practice: Mastering Claude Code and Codex in Seven Days

When Programming Turns from "Construction" into "Renovation"

A product manager with zero programming background built a deployable knowledge base system—benchmarked against Feishu—in just three days. Not a single line of code was written by hand; the entire project was completed through natural language conversations with AI. This sounds like pure fantasy, yet it is exactly what Vibe Coding is making possible right now.

Bilibili recently launched a Vibe Coding practical tutorial that its creator calls the "most complete and most detailed" available. The course covers mainstream AI programming tools including Claude Code, Codex, and Cursor, with the goal of taking zero-background learners from initial understanding to a deployed project within seven days.

Behind this tutorial lies a deeper paradigm shift: developers are transforming from "construction workers" into "property owners."

Constructor Mode vs. Owner Mode: A Fundamental Shift in the Development Paradigm

The traditional "constructor mode"—jokingly referred to in the tutorial as "ancient-method programming"—requires developers to master complex syntax rules, algorithmic logic, and low-level principles. A complete project demands collaboration across frontend, backend, database, operations, testing, and product management roles. Each developer must hand-write every line of code from scratch.

"Owner mode" is entirely different—it is goal-driven: define objectives in natural language, describe requirements, set boundaries, and let AI handle the actual technical implementation, code writing, and framework setup. The developer only needs to act as an evaluator, accepting results and continuously providing feedback and correction instructions.

The renovation analogy fits perfectly: you have a designer produce blueprints, approve them, then construction proceeds according to plan. When the work is done, you inspect it—if it doesn't meet standards, it goes back for rework until you're satisfied. When you want to upgrade in the future, you simply go through the same process again.

Does this mean technical skills no longer matter? Quite the opposite. The tutorial explicitly states: technology hasn't disappeared—rather, the human role has shifted from "item-by-item implementation" to "orchestrating iteration"—from writing line after line of code to organizing AI to complete projects.

From Chatbot to Agent: AI Programming Has Reached "L3 Autonomous Driving"

To understand why Vibe Coding works now, you first need to see the evolutionary leap AI has made from conversational tool to intelligent agent.

Early conversational tools like ChatGPT essentially stayed at the level of providing information and suggestions—answering questions and generating scattered text to assist thinking. But today's AI programming tools—Codex, Claude Code, Cursor—have developed three critical capabilities:

• Deep goal understanding: Not simple semantic matching, but comprehension of complex, multi-layered development tasks
• Multi-step execution: From building frontend pages to writing backend APIs, able to decompose and advance step by step
• Loop feedback: Continuously adjusting based on execution results and user feedback until delivery

The tutorial uses a precise analogy: AI programming has now reached the level of L3 autonomous driving. While real-world autonomous driving hasn't fully achieved L3 (hands off the wheel), AI programming can genuinely do the work for you—moving from assisted conversation toward task delivery.

The essential difference between chat tools and agents: Chatbots focus on information acquisition and assisting thought, while Agents focus on automated task execution, with closed-loop capabilities for autonomous planning, tool invocation, and result verification.

Vibe Coding was coined by AI researcher Andrej Karpathy in early 2025, referring to a programming approach where developers describe intent in natural language, fully trust AI-generated code, and no longer review it line by line. Its key prerequisite is that model capabilities have crossed a threshold: AI no longer merely completes the next line of code but can autonomously plan steps around a goal, invoke terminals and file systems, run tests, and correct errors. This is fundamentally different from traditional "Copilot-style completion"—completion remains human-led, while Vibe Coding hands the initiative to the goal itself. Precisely for this reason, its current scope leans toward prototype validation, internal tools, and small-to-medium web projects; for core systems with strict consistency and security constraints, human acceptance testing remains indispensable.

Understanding an Agent requires distinguishing it from scripts and workflows. Scripts execute preset steps, workflows follow fixed branches, but the core of an Agent is the "plan—act—observe—re-plan" loop: it decides on its own which tool to invoke next, which file to read, which command to run, and corrects subsequent actions based on returned results. What supports this capability is typically two mechanisms—tool use and context management—the former enabling the model to actually operate the environment rather than just output text, the latter allowing it to remember goals, constraints, and completed steps across long tasks. The "loop feedback" emphasized in the tutorial refers precisely to this closed loop, not simply multi-turn conversation.

Tool Selection: Why Codex Over Claude Code

On the choice of core development tools, the tutorial offers a clear preference: prioritize Codex over Claude Code.

The reason is straightforward—Anthropic, the company behind Claude Code, is extremely unfriendly to domestic Chinese users, while Codex is not only friendly to domestic users but DeepSeek^Ad has officially adapted to Codex. This means switching to domestic models with Codex is very simple and requires no complex configuration.

For model selection, the tutorial recommends flexibly matching based on task complexity and cost:

• Simple tasks: Use chat models—lower cost, faster response
• Complex tasks: Use reasoning models—stronger comprehension

As a tool platform, Codex can connect to multiple models—DeepSeek, GPT, Gemini, Tongyi Qianwen, etc.—switching as needed for the task.

Claude Code, Codex, and Cursor represent three distinct product forms, and understanding the differences helps with selection. Claude Code is a command-line Agent running in the terminal, skilled at multi-file modifications within existing codebases; Codex is also offered as an Agent but with lower barriers to connecting multiple models, making it easy to switch between DeepSeek, Tongyi Qianwen, and other domestic models per task; Cursor is a deeply modified IDE that embeds AI capabilities into the editor, better suited for scenarios requiring frequent human review and code fine-tuning. Choosing among them essentially depends on whether you value model replaceability, terminal automation level, or visual editing experience.

Zero-Background Entry: Everything You Need to Prepare

The target audience for this course is broader than you might imagine: zero-background programming learners, product managers and designers, workplace skill explorers, and independent developers.

The learning threshold is surprisingly low:

• Basic computer operation: Being able to power on and install software (like QQ, WeChat) is enough
• Basic English ability: Nine-year compulsory education English level suffices; if not, online translation tools work
• Logical thinking and requirement expression: Being able to clearly state what you want

One note: Vibe Coding is primarily done on a computer—projects are harder to build with only a phone.

What do you gain after learning? Deepened understanding of Vibe Coding, comprehension of how Agent intelligence engines work, mastery of model selection, and the ability to independently complete a zero-to-one web project from start to finish.

The Skills Mechanism: Turning Senior Developer Experience into Reusable Assets

A common pain point for beginners using AI programming: vague requirement descriptions, lack of structure, ignoring boundary conditions and technical constraints. The tutorial's solution is Skills.

Skills logic is simple: senior developers encapsulate complete, standardized, context-structured instructions, and beginners use them directly. It doesn't replace your thinking—it packages mature experience into a reusable collaboration approach.

In the course structure, Skills building is positioned after tool mastery and before project practice, as the key "experience encapsulation" step.

Context is a key concept for understanding AI programming cost and effectiveness. The amount of information a model can "see" per response has an upper limit, measured in tokens—and a token is the smallest processing unit after text is segmented, with Chinese roughly one character corresponding to one to two tokens. When conversations grow long and code files grow large, early important information gets pushed out of the window, and the model easily "forgets" requirements or constraints. This explains why encapsulating standards into Skills works: it compresses key conventions into structured, reusable fragments, injected when needed rather than all piled into the conversation. Similarly, the tutorial's suggestion to use chat models for simple tasks and reasoning models for complex tasks is also a trade-off between token cost and reasoning depth.

Course System: A Four-Step Closed Loop from Theory to Practice

The entire tutorial is designed around the closed loop of "theoretical understanding → tool mastery → experience encapsulation → project practice":

1. Environment preparation: Understanding command-line terminals, PowerShell, and basic tools
2. Core concepts: Understanding mainstream tools and models in AI programming, including key concepts like tokens and context
3. Tool mastery: Detailed explanation of how to use Codex
4. Skills building: Learning to encapsulate and reuse mature instruction templates
5. Project practice: From requirement definition to deployment, independently completing a fully functional web project

The final output is a complete practical project—walking through the entire process from requirements to deployment.

The New Definition of a Programmer

The most intriguing aspect of this tutorial is its redefinition of the "programmer" role. The tutorial states clearly: we don't need to become traditional programmers—instead, we first learn to state goals clearly, break problems apart, and verify results well.

This doesn't mean technical literacy becomes irrelevant—quite the opposite: clearly defining problems, reasonably decomposing tasks, and accurately evaluating results are themselves higher-order technical abilities. It's just that this ability no longer manifests as proficiency in hand-writing code, but as judgment in orchestrating AI to complete complex deliveries.

The core proposition of Vibe Coding is not "you don't need to learn programming anymore," but "what you learn has changed."