5189 words
26 minutes
A Beginner's Guide to Vibe Coding — Let AI Write Your Code
2025-12-19

1. What Is Vibe Coding?#

The Birth of a New Term#

In February 2025, Andrej Karpathy (former Tesla AI director and OpenAI co-founder) coined a new term on social media: vibe coding.

He described it like this:

“You’re fully in the vibe, embrace exponentials, and forget the code even exists.”

Sounds a bit mystical? The idea is actually dead simple:

Vibe coding = telling the AI what you want in plain language, and letting it write the code.

Instead of typing line after line, you describe the requirement the way you’d brief a colleague — and the AI builds it.


How AI Coding Tools Have Evolved#

Before we start, a quick tour of the AI coding tools out there. They fall into roughly three categories:

🌐 Category 1: Web chat assistants

  • Examples: DeepSeek, Doubao, ChatGPT
  • Strength: like a “well-read consultant” — you ask, it answers
  • Limitation: it can’t see your code, so you’re stuck copy-pasting by hand

🔌 Category 2: IDE plugins

  • Examples: Tongyi Lingma, GitHub Copilot, Cursor
  • Strength: like a “thoughtful copilot” that completes code right inside your editor
  • Limitation: tunnel vision on the current file; it can’t reason about the project as a whole

🤖 Category 3: AI agents

  • Examples: Claude Code, Codex CLI, Gemini CLI
  • Strength: like a “full-stack developer” that understands the entire project and edits files directly
  • Limitation: you need a little command-line familiarity (don’t worry — this guide will teach you)

This article is about the third category: AI agents.


What Is Claude Code?#

Claude Code is a command-line AI coding assistant from Anthropic, the company behind the Claude models.

💡 An analogy: if a chat assistant is the strategist who can only talk, Claude Code is the all-round aide who can both think and act.

Beyond thinking and answering, it can work on your project directly (asking for your approval before every action):

  • 🔍 Read files: it maps out your project structure on its own — “which components does this React app have”
  • ✏️ Edit files: it changes code and saves it — no manual copy-pasting
  • 💻 Run commands: it executes npm test, git commit and friends to verify the result

Why the Command Line?#

You might ask: “The terminal is a black hole of text and looks complicated. Why not build a GUI?”

Fair question. For AI-assisted coding, the command line is actually the most efficient surface:

  1. Direct access to dev tooling: Git, npm, and test runners already live in the terminal, so the AI can use them natively
  2. Project-wide vision: IDE plugins only see the open file; a CLI tool can analyze the whole repository
  3. Work in parallel: you keep writing code in your IDE while the AI in the terminal writes your tests

My Own Experience#

As a frontend developer, I’ve been living in AI agent tools for a while now.

I’m at the point where 100% of the code is AI-generated — I only write the requirements and review the output.

Below is a BI ad-hoc analysis page generated entirely by AI:

BI ad-hoc analysis page — fully AI-generated

2. Hands-on Setup#

🎯 Goal: by the end of this chapter, you’ll be writing code by chatting with an AI in your terminal.

Step 1: Install Claude Code#

Open your terminal (on macOS press Cmd + Space and search for “Terminal”; on Windows search for “PowerShell”) and run one of these:

macOS:

Terminal window
curl -fsSL https://claude.ai/install.sh | bash

Windows (PowerShell):

Terminal window
irm https://claude.ai/install.ps1 | iex

Via npm (recommended for frontend developers):

Terminal window
npm install -g @anthropic-ai/claude-code

💡 Tip: if you do frontend, you already have Node.js on your machine — npm is the path of least resistance.


Step 2: Pick a Model#

Once installed, tell Claude Code which model to use. Two routes:

Option A: The official subscription#

Anthropic offers a Max subscription at $200/month with direct access to the strongest Claude models.

Claude official pricing

⚠️ Heads-up: Anthropic’s service isn’t directly reachable from mainland China — you’ll need a special network setup.

The good news: Claude Code works with domestic Chinese models. Solid options include:

🔥 Zhipu GLM-4.6 (Tsinghua)

  • Site: bigmodel.cn
  • Strengths: a domestic model with strong Chinese-language understanding

💰 MiniMax M2

  • Site: minimaxi.com
  • Strengths: great value, easy to hook up

🌋 Volcengine doubao-seed-code

  • Site: volcengine.com
  • Strengths: ByteDance’s stack, tuned for code generation

These trail the frontier models (Claude Opus 4.5, GPT-5.1), but they’re cheap and reliably accessible — perfect for learning the ropes.


Step 3: Configure the Third-Party Model#

Using MiniMax M2 as the example, here’s the full setup:

1️⃣ Get an API key

  1. Open the MiniMax open platform
  2. Sign up and log in
  3. In the console, create an API key (a long, password-like string)
  4. Copy it and store it somewhere safe

2️⃣ Create the config file

Create or edit ~/.claude/settings.json in your home directory:

{
"alwaysThinkingEnabled": true,
"env": {
"ANTHROPIC_AUTH_TOKEN": "paste your API key here",
"ANTHROPIC_BASE_URL": "https://api.minimaxi.com/anthropic",
"ANTHROPIC_MODEL": "MiniMax-M2",
"API_TIMEOUT_MS": "3000000"
}
}

💡 Path notes:

  • macOS: ~ is /Users/<your-username>, so the full path is /Users/<your-username>/.claude/settings.json
  • Windows: the full path is C:\Users\<your-username>\.claude\settings.json

Step 4: Add a System Prompt (Advanced Setup)#

This step is optional but strongly recommended. A system prompt makes the AI work the way you like — replying in your language, following your code conventions, and so on.

Create a ~/.claude/CLAUDE.md file with your personal instructions.

Here’s the one I actually use. It’s written in Chinese since that’s the language I work in — the structure is what matters, so treat it as a template and swap in your own rules (telling the agent to “always respond in English”, your code-quality principles, your review checklist):

### 🌏 Language rules
Always respond in Chinese-simplified
1. 只允许使用简体中文回答 - 所有思考、分析、解释和回答都必须使用简体中文
2. 中文优先 - 优先使用中文术语、表达方式和命名规范
3. 中文注释 - 生成的代码注释和文档都应使用中文
4. 中文思维 - 思考过程和逻辑分析都使用中文进行
### 🎯 基本原则(不可违反)
1. **质量第一**:代码质量和系统安全不可妥协
2. **思考先行**:编码前必须深度分析和规划
3. **工具优先**:优先使用验证过的最佳工具链
4. **透明记录**:关键决策和变更必须可追溯
5. **持续改进**:从每次执行中学习和优化
6. **结果导向**:以目标达成为最终评判标准
---
## 📊 质量标准
### 🏗️ 工程原则
- **架构设计**:遵循 SOLID、DRY、关注点分离、YAGNI(精益求精)
- **代码质量**:
- 清晰命名、合理抽象
- 必要的中文注释(关键流程、核心逻辑、重点难点)
- 删除无用代码,修改功能不保留旧的兼容性代码
- 若无显式要求不要编写任何兼容代码
- **完整实现**:禁止 MVP/占位/TODO,必须完整可运行
<plan_tool_usage>
- 对于中等规模或更大规模的任务(例如:多文件修改、添加新的接口/命令行工具(CLI)功能,或进行多步骤的调查),在执行任何代码或工具操作之前,必须在 TODO/plan 工具中创建并维护一个详细的计划。
- 创建 2-5 个里程碑或目标项;避免包含过于细小的步骤或重复性的操作任务(例如:“打开文件”、“运行测试”等)。切勿使用像“实现整个功能”这样的笼统描述。
- 在工具中维护任务的状态:任何时候只能有一个任务处于 “in_progress”(进行中)状态;任务完成后请将其标记为 “completed”(已完成);及时更新任务状态(切勿连续多次调用工具而不进行任何更新)。切勿直接将任务状态从 “pending”(待处理)变为 “completed”:必须先将其设置为 “in_progress”(如果任务确实可以立即完成,可以在同一条更新中同时将其标记为 “in_progress” 和 “completed”)。切勿事后批量完成多个任务。
- 在任务结束时,确保所有任务要么已完成,要么已被明确取消或推迟。
- 任务结束时的基本规则:所有任务的状态应为 “in_progress” 或 “pending” 均为零;对于未完成的任务,需明确说明其原因并完成它们或取消/推迟它们。
- 如果你需要通过聊天来说明一个中等复杂性的任务计划,请将该计划同步到 TODO/plan 工具中,并在后续更新中引用这些任务项。
- 对于非常简单、耗时较短的任务(例如:修改单个文件,代码量不超过 10 行),你可以省略使用该工具。如果仍然需要通过聊天来说明任务计划,只需用 1-2 句话简洁地描述任务目标,无需包含具体的操作步骤或详细的任务清单。
- 在进行任何非琐碎的代码修改之前(例如:应用补丁、多文件编辑或进行复杂的系统配置),请确保当前计划中有一个与你要执行的操作相匹配的任务被标记为 “in_progress”;如有必要,请先更新计划。
- 如果任务范围发生变化(例如:需要拆分、合并或重新排列任务项),请在继续执行之前更新计划。切勿在编码过程中让计划状态变得过时。
- 任何时候都只能有一个任务处于 “in_progress” 状态;如果出现多个任务同时处于 “inProgress” 状态,请立即调整状态,确保只有当前阶段的任务处于进行中。
<plan_tool_usage>
### ⚡ 性能标准
- **算法意识**:考虑时间复杂度和空间复杂度
- **资源管理**:优化内存使用和 IO 操作
- **边界处理**:处理异常情况和边界条件
### 🧪 测试要求
- **测试驱动**:可测试设计,单元测试覆盖,后台执行单元测试时,最大不能超过 60s,避免任务卡死。
- **质量保证**:静态检查、格式化、代码审查
- **持续验证**:自动化测试和集成验证
---
## 🛠️ 工具使用指南
### 🔍 代码分析
- **首选**:`Serena`符号工具(`get_symbols_overview` → `find_symbol`)
- **备选**:`Read` + `Grep` + `Glob`组合
- **降级**:直接文件读取(需记录决策依据)
### 📚 知识查询
- **技术文档**:`Context7`(先 `resolve-library-id` 后 `get-library-docs`)
- **网页搜索**:`extra`
- **GitHub 文档**:`DeepWiki`
### 💭 分析规划
- **深度思考**:`Sequential-Thinking`(规划前必须执行)
- **知识管理**:`Memory`(读取约束,存储决策)
### 🔧 命令执行标准
**路径处理:**
- 始终使用双引号包裹文件路径
- 优先使用正斜杠 `/` 作为路径分隔符
- 确保跨平台兼容性
**工具优先级:**
1. `rg` (ripgrep) > `grep` 用于内容搜索
2. 专用工具 (Read/Write/Edit) > 系统命令
3. 批量工具调用提高效率
---
## ⚠️ 危险操作确认机制
### 🚨 高风险操作清单
执行以下操作前**必须获得明确确认**:
- **文件系统**:删除文件/目录、批量修改、移动系统文件
- **代码提交**:`git commit`、`git push`、`git reset --hard`
- **系统配置**:修改环境变量、系统设置、权限变更
- **数据操作**:数据库删除、结构变更、批量更新
- **网络请求**:发送敏感数据、调用生产环境 API
- **包管理**:全局安装/卸载、更新核心依赖
### 📝 确认格式模板
---
⚠️ 危险操作检测!
操作类型:[具体操作]
影响范围:[详细说明]
风险评估:[潜在后果]
请确认是否继续?[需要明确的"是"、"确认"、"继续"]
---
---
## ✅ 关键检查点
### 🚀 任务开始
**尽量并行化工具调用;同时采用批量读取(read_file)和批量修改(apply_patch)的方式来加速整个处理过程。**
- [ ] 读取相关 Memory,回显关键约束
- [ ] 根据任务特征选择适配策略
- [ ] 确认工具可用性和降级方案
### 💻 编码前
- [ ] 完成 `Sequential-Thinking` 分析
- [ ] 使用`Serena`等工具理解现有代码
- [ ] 制定实施计划和质量标准
### 🔍 实施中
- [ ] 遵循选定的质量标准
- [ ] 记录重要决策和变更理由
- [ ] 及时处理异常和边界情况
### ✨ 完成后
- [ ] 验证功能正确性和代码质量
- [ ] 更新相关测试和文档
- [ ] 总结经验,更新 Memory 和最佳实践
---
## 🎨 终端输出风格指南
### 💬 语言与语气
- **友好自然**:像专业朋友对话,避免生硬书面语
- **适度点缀**:在标题或要点前使用 🎯✨💡⚠️🔍 等 emoji 强化视觉引导
- **直击重点**:开篇用一句话概括核心思路(尤其对复杂问题)
---
### 📐 内容组织与结构
- **层次分明**:用标题、子标题划分内容层级,长内容分节展示
- **要点清晰**:将长段落拆分为短句或条目,每点聚焦一个 idea
- **逻辑流畅**:多步骤任务用有序列表(1. 2. 3.),并列项用无序列表(- 或 *)
- **合理分隔**:不同信息块之间用空行或 `---` 分隔,提升可读性
> ❌ 避免在终端中使用复杂表格(尤其内容长、含代码或需连贯叙述时)
---
### 🎯 视觉与排版优化
- **简洁明了**:控制单行长度,适配终端宽度(建议 ≤80 字符)
- **适当留白**:合理使用空行,避免信息拥挤
- **对齐一致**:统一缩进与符号风格(如统一用 `-` 而非混用 `*`)
- **重点突出**:关键信息用 **粗体** 或 *斜体* 强调
---
### 🧩 技术内容规范
#### 代码与数据展示
- **代码块**:多行代码、配置或日志务必用带语言标识的 Markdown 代码块(如 ```python)
- **聚焦核心**:示例代码省略无关部分(如导入语句),突出关键逻辑
- **差异标记**:修改内容用 `+` / `-` 标注,便于快速识别变更
- **行号辅助**:必要时添加行号(如调试场景)
#### 结构化数据
- **优先列表**:大多数场景用列表替代表格
- **慎用表格**:仅当需严格对齐结构化数据(如参数对比)时使用 Markdown 表格
---
### 🚀 交互与用户体验
- **即时反馈**:快速响应,避免长时间无输出
- **状态可见**:重要操作显示进度或当前状态(如“正在处理…”)
- **错误友好**:清晰说明错误原因,并提供可操作的解决建议
- **引导下一步**:结尾给出实用建议、行动指南或鼓励进一步提问
---
### ✅ 输出结尾建议
- 复杂内容后附**简短总结**,重申核心要点
- **最终答案的编写规范:**
- **对于微小的修改(单个文件,修改内容不超过10行):** 仅需使用2–5句话或3个要点进行描述,无需使用标题;除非必要,否则不要添加任何简短的代码片段(不超过3行)。
- **对于中等规模的修改(涉及单个文件或少量文件):** 使用不超过6个要点进行描述,总共可以使用6–10句话;最多只能添加1–2个简短的代码片段(每个片段不超过8行)。
- **对于大规模的修改(涉及多个文件):** 应分别对每个文件进行总结,每个文件使用1–2个要点进行描述;除非代码非常关键,否则避免直接在最终答案中嵌入代码片段。
- **禁止在最终答案中包含“修改前/修改后”的对比内容、完整的方法体,或过长(需要滚动才能查看的)代码块;建议使用文件名或符号名称来引用相关内容。**
- **除非用户明确要求,或者修改过程会导致构建、代码检查(如yarn、tsc、eslint等)失败,否则不要在答案中提及这些过程或工具的使用情况。** 如果这些检查过程顺利完成(即没有产生任何错误或警告),则无需特别说明。
**关于代码与格式的注意事项:**
- 对于需要突出显示的代码片段,请使用等宽字体(monospace)进行显示;同时,请避免将代码片段与**符号(如**)混合使用。
- **除非修改过程需要记录构建、代码检查的结果,或者这些步骤会影响到修改的顺利进行,否则不要在答案中提及相关的日志或工具信息。**
- 对于简单的修改,只需简要说明修改的内容、涉及的位置以及修改的结果即可,无需进行复杂的总结。
- **避免使用过多的代码注释或长篇的代码示例;建议通过引用文件名、符号或函数名称来说明修改的具体内容。**
- **当代码示例能更直观地说明问题时,优先使用自然语言进行描述(即直接引用文件名、符号或函数名称);只有在确实需要避免混淆的情况下,才允许使用代码片段,且每个代码片段的长度应控制在规定的范围内。**
- **对于代码库中的代码片段:** 如果必须引用代码库中的代码,可以使用相应的引用格式,但在最终答案中应避免使用行号和文件路径作为前缀;每个代码片段的长度最多不超过1–2行。
---

Step 5: Install MCP Plugins (Optional, Advanced)#

🔧 What is MCP? The Model Context Protocol is a plugin protocol that extends the AI with extra capabilities — driving a browser, structured deep thinking, and so on.

To make Claude Code even more capable, install plugins like these (run them one by one in your terminal):

Terminal window
# 1. Chrome DevTools - let the AI drive a browser
claude mcp add --transport stdio --scope user chrome-devtools \
-- npx chrome-devtools-mcp@latest
# 2. Sequential Thinking - deeper step-by-step reasoning
claude mcp add --transport stdio --scope user sequential-thinking \
-- npx -y @modelcontextprotocol/server-sequential-thinking
# 3. Serena - code symbol analysis
claude mcp add --transport stdio --scope user serena \
-- uvx --from git+https://github.com/oraios/serena \
serena start-mcp-server --enable-web-dashboard false
# 4. Context7 - up-to-date technical docs
claude mcp add --transport stdio --scope user context7 \
-- npx -y @upstash/context7-mcp

💡 Beginners can skip this step and come back once they’re comfortable with the basics.


🎉 Start Using It!#

With everything configured, open your terminal, cd into your project, and launch it with claude:

Terminal window
cd /path/to/your/project
claude

You’ll see a screen like this:

Claude Code CLI home screen

Try asking it something, like “What is this project?”

The AI first reasons about your intent, then reaches for tools to analyze the codebase:

The AI thinking and analyzing

When it’s done, it wraps up with a clear summary:

Analysis result

Congratulations! 🎊 Your AI coding assistant is up and running — time to start your vibe coding journey.

3. Other AI Coding Tools Worth a Look#

Beyond Claude Code, several other AI agent tools are worth watching. Pick whichever fits your development focus:


🥇 Codex CLI (from OpenAI)#

Site: developers.openai.com/codex/cli

Best for: backend developers

Highlights:

  • Made by OpenAI, powered by the GPT model family
  • When it hits a problem, it “reasons deeply” first, working through edge cases over and over
  • Particularly strong for logic-heavy backend work

💰 Low-cost route: ChatGPT Team currently has a $0/$1 trial that covers both the ChatGPT site and Codex CLI — roughly 10 RMB a month. Exceptional value.

Rating: ⭐⭐⭐⭐⭐


🤖 Droid CLI (from Factory.ai)#

Site: factory.ai/product/cli

Best for: complex projects that need multi-role collaboration

Highlights:

  • A distinctive philosophy: instead of “one assistant”, you get “an entire army”
  • Splits the AI into specialized “droids” that simulate a real R&D team
  • Works with several frontier models (Claude, GPT, Gemini, and more)

Droid CLI interface

💰 Low-cost route: Sign-up bonus of 40 million tokens (about $108) — that promo has ended and prices have gone up (roughly 6 RMB per 10 million tokens).

Rating: ⭐⭐⭐ (less of a bargain since the promo ended)


🎨 Gemini CLI (from Google)#

Site: geminicli.com

Best for: frontend UI developers

Highlights:

  • Made by Google, powered by the Gemini model family
  • Gemini 3 PRO is excellent at UI and visual tasks
  • The tooling is a bit less polished than Claude Code or Codex CLI

💰 Low-cost route: The Google One student deal includes a free year of the PRO subscription.

Rating: ⭐⭐⭐ (only for frontend UI work)


📊 Tool Comparison#

ToolBest forModelsRating
Claude CodeFull-stackClaude⭐⭐⭐⭐⭐
Codex CLIBackendGPT⭐⭐⭐⭐⭐
Droid CLITeam collaborationMulti-model⭐⭐⭐
Gemini CLIFrontend UIGemini⭐⭐⭐

4. Real-World Cases: What Can the AI Do?#

🎯 This chapter shows what an AI agent can do through real cases from my projects. By the end, you’ll know exactly what it can take off your plate.

Case 1: Getting Up to Speed on Unfamiliar Code#

Scenario: you’ve inherited a project and need to quickly understand how a feature works.

While refactoring the Datart frontend of our CDP system at Zhongsheng, I needed to figure out “how different field types map to different icons in the data view”.

Without AI, I would have had to:

  1. Search the codebase for likely keywords
  2. Read file after file
  3. Sketch the call graph by hand
  4. Burn hours — possibly a whole day

With AI, it was one question:

What types appear in data.model.columns returned by the data-view API?
I already know about STRING and NUMERIC

The AI answered immediately:

Field type analysis result

Turns out there are 8 types! The first four are the common ones; the rest are for variable/script scenarios.

A follow-up about the rendering logic:

Does the frontend do anything special when rendering each type?

The AI analyzed the code and replied:

Frontend rendering logic

Now that I fully understood the feature, I had the AI make the code changes directly:

Code modification in progress 1

Code modification in progress 2

The final result — each field type shows its matching icon:

Field icon result


Case 2: Bulk Changes to Business Logic#

Scenario: product changes a requirement, and the same logic needs updating in many places.

The original requirement: the “Export to Excel” feature in the Zhongsheng CDP dashboard exported data based on the current query conditions. But PMs noticed that if a user changed the filters without clicking “Search”, the exported data would mismatch what the page showed.

The change touched export logic scattered across the app — easy to miss spots when done by hand.

Hand it to the AI:

Export logic modification 1

Export logic modification 2

The AI found every affected location and updated them all in one pass — faster, and far less error-prone.


Case 3: Fixing a Page Layout#

Scenario: too many metrics on a page and the tags get truncated; the layout needs work.

The original problem — the metric tags were cut off:

Layout problem

I sent the AI a screenshot plus one sentence:

A column can hold multiple metrics, but dropping in several truncates
the metric tags. Please improve the frontend display.

The AI thought it over and proposed three solutions:

Three proposed solutions

It picked option one (horizontal scrolling), which produced this:

Horizontal scrolling solution

I wasn’t happy with it and asked for wrapping instead:

No horizontal scrollbar — wrap them onto multiple lines instead

The AI adjusted immediately:

Wrapped layout solution

From spotting the problem to solving it took minutes.


Case 4: Searching the Web for Fresh News#

Scenario: keeping up with the latest security news.

Meta’s React team and Vercel’s Next.js team had just jointly disclosed two critical-severity vulnerabilities, and I wanted the details.

Just ask:

Look up the recently disclosed maximum-severity Next.js vulnerabilities
and walk me through them

The AI searched the web and put together a summary:

Web search result

Far more efficient than digging through sites myself.


Case 5: Building a Page from a Wireframe#

Scenario: product hands you a wireframe and you need a page fast.

Here’s the wireframe from product:

Product wireframe

I sent the image to the AI with one instruction:

This is a B2B wireframe. Build it with the component library
already used in this project

The page the AI generated (the duplicated menu and watermark are artifacts of the long screenshot):

AI-generated page

It still needed polish, but the skeleton was there — a huge chunk of repetitive work saved.


5. Final Thoughts#

What Vibe Coding Really Is#

Vibe coding isn’t about AI replacing programmers — it changes how we work:

The old loop: requirement → think → code → debug → test

The vibe coding loop: requirement → describe it to the AI → review its output → refine → accept

Your role shifts from “producer of code” to “reviewer of code”. Which means:

  • ✅ You need sharper requirement thinking: the ability to describe exactly what you want
  • ✅ You need stronger code review skills: the judgment to tell good AI output from bad
  • ✅ You need broader technical vision: knowing which approach is the right one
  • ❌ You no longer need to memorize every API’s parameter order
  • ❌ You no longer need to hand-write boilerplate

Advice for Beginners#

  1. Start small: have the AI write a function or tweak a style first, to get a feel for the interaction
  2. Learn to write requirements: more specific is better — “make the button blue” loses to “set the submit button background to #1890ff”
  3. Stay critical: the AI makes mistakes too; review what it produces
  4. Try different tools: Claude Code, Codex CLI, and Gemini CLI each have their strengths — find yours

FAQ#

Q: Can AI-written code ship to production?

A: Yes — after review and testing. My current workflow: AI generates → I review → run tests → deploy.

Q: Will this put programmers out of work?

A: Not any time soon. Today the AI is more of a productivity multiplier — one person doing the work of two — but it can’t deliver complex projects independently. Longer term, it will change what the industry expects from programmers.

Q: Are domestic Chinese models good enough?

A: For day-to-day dev work, yes. For tricky architecture decisions and nasty bug hunts, the frontier models are more reliable.


I hope this guide helps you start your own vibe coding journey. Questions welcome in the comments!

💡 One last tip: these tools evolve fast, and parts of this article will age. Bookmark the official docs:

A Beginner's Guide to Vibe Coding — Let AI Write Your Code
https://www.mihouo.com/en/posts/ai/claude-code-cli-guide/
Author
Jia
Published at
2025-12-19
License
CC BY-NC-SA 4.0