# 32 Claude Code hacks that take you from beginner to PRO in 16 minutes.
**作者**: Codez
**日期**: 2026-05-30T14:03:43.000Z
**来源**: [https://x.com/0xCodez/status/2060723834617999592](https://x.com/0xCodez/status/2060723834617999592)
---
4% of all public GitHub commits are now written by Claude Code - about 135,000 a day. The average user knows maybe six of the 32 hacks that actually unlock it. The rest of this article is the other 26 - including the two features Anthropic shipped two days ago.
Here’s the full map, every hack verified, including the two that shipped this week.
> Follow my Substack to get fresh AI alpha: movez.substack.com
This is built from Anthropic’s own docs, the official Claude Code release notes, and the power-user tips section in their help center. Every hack here is something that actually exists as of May 2026 - not folklore, not deprecated, not “coming soon.”
We organize them in three tiers, from your first session to running parallel agent teams that finish work while your laptop is closed.
32 hacks. 3 tiers. One terminal that runs your whole stack.
## Part 1 · Foundation
> 01. Run /init on every project.
The first thing to do in any project - new or existing. /init scans your codebase and writes a CLAUDE.md file that maps your architecture, conventions, and key files.
From now on, every session starts with that context loaded automatically. You stop re-explaining your project.
> 02. Set up a /statusline. Mini-dashboard in your terminal.
The single best anti-anxiety upgrade. /statusline generates a script that pins a live bar to the bottom of your session - model, context %, cost, branch, whatever you want. You stop guessing how close you are to context rot.
> 03. Use voice mode. You talk 3× faster than you type.
Voice mode is now available in Claude Code, Desktop, and Cowork — to everyone. The Anthropic team itself codes mostly by voice. The reason isn’t gimmick: you speak roughly 3× faster than you type, so your prompts get more detailed without taking more time.
Detailed prompts = better output. Free speed.
> 04. Keep your context small. Don’t dump the whole codebase.
Only give Claude what the current task needs. Break big problems into small focused steps. Less noise = better output - and it’s the single most-ignored basic. The next hack tells you exactly where the bloat is hiding.
> 05. Run /context to find token bloat. Diagnose, don’t guess.
/context shows exactly what’s eating your tokens - system prompt, files, MCP servers, conversation history - broken down by percentage. If a session feels heavy, this is the first command you run.
Usually one MCP server you don’t need is hogging 30% of your window.
> 06. Compact at 60%. Clear between tasks.
When context hits ~60%, run /compact - Claude summarizes older messages and gives you back your window. You can even steer what it keeps: “/compact but preserve the auth decisions and DB schema.”
When you’re switching to an entirely different task, /clear wipes the slate (CLAUDE.md stays loaded - you’re not starting from zero).
> 07. Always start in "plan mode"
Cycle modes with Shift+Tab until you land on Plan Mode. Claude can read, search, research - but won’t modify anything until you approve. It outlines the approach, asks clarifying questions, lists files it’ll touch.
You catch wrong assumptions in one sentence instead of forty files. This single habit cuts revisions dramatically.
> 08. Treat Claude like a junior developer.
Instead of “write a function that does X,” ask “how should we handle X? What are the tradeoffs?” Reasoning through a problem first produces better code than pattern-matching from a command. You also learn its assumptions, which is where the real bugs hide.
> 09. Make Claude ask questions. “Until you’re 95% confident.”
Append this to any non-trivial request: “Continuously ask me questions until you’re 95% confident you understand what I need and what you’ll do.” Three rounds of clarification beat three rounds of revision every time. This works especially well in plan mode (hack 7).
> 10 . Bake self-checks into the todo list.
When Claude makes a todo list, ask it to add verification steps as actual items: “Take a screenshot. Open DevTools and check for errors. Run the tests.”
Plus the magic line: “Don’t move to the next todo until you’re 95% confident the current one is good.” You stop getting features that look done and aren’t.
## PART 2 · Control
> 11. Deploy subagents for parallel work.
Tell Claude to “use subagents” for complex tasks. Each subagent gets its own context window, can use a different model, and works in parallel - research, tests, exploration. They report back to the main session.
Pair with model tiers (hack 15) and run subagents on cheap Haiku while your main thread stays on Opus.
> 12. Build custom Skills. Reusable workflows in markdown.
Drop a SKILL.md file in .claude/skills/<name>/ and Claude auto-loads it when the task matches the description. A skill is just frontmatter + markdown instructions - but because it loads just-in-time (~100 tokens dormant, ~5K when needed), you can have dozens installed without context cost.
> 13. Use hooks for what must always happen.
Hooks are shell scripts that fire automatically at specific events: PreToolUse, PostToolUse, session start/stop, subagent completion. They run outside the model’s reasoning so they cannot be skipped. Use for: format-on-edit, block dangerous bash, run lint before commits.
> 14. Edit permissions for safe autonomy.
Don’t YOLO with --dangerously-skip-permissions. Use the /permissions command (or ~/.claude/settings.json) to explicitly allow safe commands and deny destructive ones.
Deny rules beat allow rules, so dangerous patterns are blocked even if a generic allow would match. Same speed, none of the danger.
> 15. Match the model to the task. Opus, Sonnet, Haiku - on purpose.
Switch right inside the session: /model opus for architecture and gnarly debugging, /model sonnet for day-to-day building, /model haiku for cheap exploration like “find every file that imports X.” One model for everything is leaving capability or money on the table.
> 16. Use /memory to edit CLAUDE.md inline.
When you realize mid-session that a convention should live permanently, run /memory to open CLAUDE.md in-place. Faster than alt-tabbing to your editor, and the change is loaded immediately for the rest of the session.
> 17. Run /review for built-in code review.
/review is a bundled skill that walks your recent changes with a structured review pass - security, style, edge cases. Faster than asking a teammate, and catches things the original session missed because it was in build mode, not review mode.
> 18. Track spend with /cost. Know what each session costs.
/cost shows token usage and dollar cost for the current session. Useful for finding which sessions are silently expensive (usually: too-big MCP servers, too-long context). Pair with the statusline (hack 2) to make it always-visible.
> 19. Press Esc Esc to rewind. The undo button for sessions.
Double-tap Escape and Claude rewinds to a previous point in the conversation. Crucial when a session drifts - instead of fighting it or starting over, just rewind to before the drift and rephrase. Most users never even know this exists.
> 20. Type # for quick memory pins. Add to CLAUDE.md without leaving.
Start any line with # and Claude treats it as a memory instruction - it adds the text to CLAUDE.md without breaking your flow. Perfect for capturing a convention the moment you realize it: # always use named exports, never default.
## PART 3 · Scale
Hacks 21-32 - Claude Code as a platform. Includes May-28 features.
> 21. Run parallel sessions with git worktrees. --worktree feature-name.
Native since Claude Code v2.1.50. Run two Claude sessions on the same repo without them stomping on each other:
Each worktree is an isolated branch with its own working directory. Three Claude sessions, three branches, zero conflicts. Merge back when done, like any git branch.
> 22. Use API endpoints instead of MCP
MCP loads all a server’s tool definitions into context - a typical 5-server setup can eat 55K tokens before you say a word. If you only need one thing (e.g. reading one Notion database), just hardcode the API endpoint. Less flexible, far cheaper. Use MCP for exploration, hardcode for production.
> 23. Use /loop for recurring tasks.
Requires Claude Code v2.1.72+. /loop 5m check the deployment status reruns the prompt every five minutes within the same session. Great for babysitting a deploy, watching a PR, polling a build. Loops are session-scoped and auto-expire after 3 days for safety.
> 24. Schedule Desktop tasks.
For automation longer than a session, use the Claude Desktop scheduled tasks feature. Each fire opens a fresh session (no shared context with previous runs), but it survives terminal exits and laptop restarts. Use for: morning issue triage, weekly metric pulls, nightly log scans.
> 25. Use Routines for laptop-off automation.
Routines run on Anthropic’s infrastructure - your laptop can be off. Schedule a routine via API call, GitHub event, or fixed cron.
Pair with sub-agents for cohesive overnight work: “review yesterday’s PRs, summarize, post to Slack at 8am.” This is the missing orchestration layer for async teams.
> 26. Control sessions from your phone.
Start a session locally, scan a QR code with your phone, keep steering it from anywhere. Your code never leaves your machine - only the control channel goes mobile. Useful for: kicking off heavy tasks at desk, monitoring from a walk, approving permissions from the gym.
> 27. Use UltraThink for hard problems.
Type “ultrathink” in your prompt and Claude allocates the maximum extended-thinking budget before responding. Don’t use it for trivial fixes - but for architecture decisions, complex debugging, or refactors that touch the whole system, the quality jump is real and visible. Tokens cost more; mistakes cost more not using it.
> 28. Build agent teams. Subagents that talk to each other.
Sub-agents (hack 11) work in isolation. Agent teams let them share a task list, communicate, and assign work to each other. You can talk to any team member directly instead of routing through the main agent. More expensive, longer runs - but for big multi-domain projects, the cohesion is worth it.
> 29. Install Context7 MCP. Up-to-date docs for any library.
Claude’s training has a cutoff, so it can suggest deprecated APIs. Context7 MCP injects up-to-date, version-specific docs from thousands of libraries - React, Next.js, Postgres, you name it - before Claude writes any code. One install, quality jump across every library.
> 30. Browse /plugin marketplace. Pre-built skills and agents.
The plugin marketplace is full of pre-packaged Skills, agents, and commands you can install instead of writing your own. Context7 (hack 29) is one example. Browse before you build - there’s a good chance someone already shipped what you need.
> 31. Trigger Dynamic Workflows. Up to 1,000 subagents in parallel.
Shipped two days ago alongside Claude Opus 4.8. Dynamic Workflows let Claude take a task too big for one session, plan it, fan out across up to 1,000 parallel subagents, run a second wave of agents to refute each finding, iterate until results agree, and hand you the consolidated answer.
The orchestration plan lives in a JavaScript script Claude writes on the fly - not in the context window - which is what makes 500-agent runs feasible at all. Activation is a single keyword:
Requires Claude Code v2.1.154+. On by default for Max and Team; Enterprise admins enable it; Pro users turn it on manually in /config. Trigger by saying “create a workflow” or by setting effort to ultracode (next hack).
Cap: 1,000 subagents per workflow. Cost: significantly more tokens than a single-agent run 0 use it where the task scale justifies it.
> 32. Set /effort ultracode. Claude decides when to fan out.
The companion to Dynamic Workflows. /effort ultracode sets reasoning effort to xhigh and lets Claude automatically decide when a task is big enough to warrant a workflow. A single request can become multiple workflows in sequence - one to understand the code, one to apply the change, one to verify.
Session-scoped: it stays on until you change it or start a new session. Drop back to /effort high for routine work, because ultracode burns substantially more tokens than a standard session. Anthropic’s own recommendation: pair it with Auto Mode so parallel subagents aren’t blocked on permission prompts.
## § The habits that keep beginners beginners
- No CLAUDE.md. Re-explaining your project every session and getting the answer wrong every session.
- Never checking /context. You can’t fix bloat you don’t see.
- Skipping plan mode. Forty-file diffs to fix a one-sentence misunderstanding.
- YOLO permissions. Speed is great until rm -rf runs in the wrong directory.
- One model for everything. Burning Opus tokens on Haiku tasks.
- Ignoring the marketplace. Building skills that already exist as plugins.
- Not knowing what shipped this week. The biggest features (Dynamic Workflows, ultracode) often launch quietly.
## Conclusion:
Claude Code didn’t get good because of one feature. It got good because thirty-two of them stack - CLAUDE.md gives you context, plan mode catches assumptions, Skills package workflows, hooks enforce rules, worktrees parallelize, MCP connects, Dynamic Workflows orchestrate a thousand agents. Each one helps. Together they change what’s possible.
Most people will use six of them, blame Claude when it misses, and move on. The 4% writing commits today are the ones who keep stacking.
Pick one hack you weren’t using - probably /init or plan mode - and add it tomorrow. Then the next. The gap between beginner and PRO is exactly this list, applied.
## 相关链接
- [Codez](https://x.com/0xCodez)
- [@0xCodez](https://x.com/0xCodez)
- [57K](https://x.com/0xCodez/status/2060723834617999592/analytics)
- [movez.substack.com](https://movez.substack.com/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [10:03 PM · May 30, 2026](https://x.com/0xCodez/status/2060723834617999592)
- [57.6K Views](https://x.com/0xCodez/status/2060723834617999592/analytics)
- [View quotes](https://x.com/0xCodez/status/2060723834617999592/quotes)
---
*导出时间: 2026/5/31 13:03:14*
---
## 中文翻译
# 32 个 Claude Code 技巧，助你在 16 分钟内从新手变专家。
**作者**: Codez
**日期**: 2026-05-30T14:03:43.000Z
**来源**: [https://x.com/0xCodez/status/2060723834617999592](https://x.com/0xCodez/status/2060723834617999592)
---
目前，GitHub 上所有的公开提交中有 4% 是由 Claude Code 编写的——每天约 135,000 次。普通用户可能只知道 32 个技巧中的 6 个，而正是这些技巧真正解锁了它的潜能。文章的其余部分将介绍另外 26 个技巧——包括 Anthropic 两天前发布的两个新功能。
这里有一份完整的技巧图鉴，每一个都已验证，包括本周发布的两个新功能。
> 关注我的 Substack 获取最新 AI 独家资讯：movez.substack.com
本文基于 Anthropic 的官方文档、Claude Code 的官方发布说明以及其帮助中心的专家用户建议部分。这里的每一个技巧都是截至 2026 年 5 月确实存在的功能——不是都市传说，不是已废弃的功能，也不是“即将推出”。
我们将它们分为三个层级，从你的第一次会话到当你合上笔记本电脑时仍在后台运行的并行智能体团队。
32 个技巧，3 个层级，一个运行你整个技术栈的终端。
## 第一部分 · 基础
> 01. 在每个项目上运行 /init。
在任何项目中——无论是新项目还是旧项目——首先要做的就是这件事。/init 会扫描你的代码库并编写一份 CLAUDE.md 文件，其中绘制了你的架构、约定和关键文件。
从现在起，每次会话都会自动加载该上下文。你将不再需要反复解释你的项目。
> 02. 设置 /statusline。终端中的迷你仪表板。
这是对抗焦虑的最佳升级。/statusline 会生成一个脚本，在会话底部固定一个实时状态栏——显示模型、上下文百分比、成本、分支，以及你想要的任何信息。你不再需要猜测自己离上下文溢出还有多远。
> 03. 使用语音模式。你说话的速度比打字快 3 倍。
语音模式现在已向所有人开放于 Claude Code、Desktop 和 Cowork 中。Anthropic 团队自己主要也是通过语音来写代码。原因不是为了噱头：你的说话速度大约比打字快 3 倍，因此你的提示词可以更详细，而不会占用更多时间。
详细的提示词 = 更好的输出。免费提速。
> 04. 保持上下文精简。不要倾倒整个代码库。
只给 Claude 提供当前任务需要的内容。将大问题拆解为小而专注的步骤。噪音越少 = 输出越好——这是最常被忽视的基础。下一个技巧会告诉你臃肿藏在哪里。
> 05. 运行 /context 查找 Token 臃肿。诊断，别靠猜。
/context 会精确显示是什么在吃掉你的 Token——系统提示词、文件、MCP 服务器、对话历史——并按百分比细分。如果会话感觉沉重，这是你要运行的第一条命令。
通常，一个你不需要的 MCP 服务器会占据 30% 的窗口。
> 06. 在 60% 时压缩。任务之间清除。
当上下文达到约 60% 时，运行 /compact —— Claude 会汇总较早的消息并归还你的窗口空间。你甚至可以引导它保留内容：“/compact 但保留认证决策和数据库架构。”
当你切换到完全不同的任务时，/clear 会彻底清空会话（CLAUDE.md 仍会加载——你并非从零开始）。
> 07. 始终以“计划模式”开始
使用 Shift+Tab 循环切换模式，直到你进入计划模式。Claude 可以阅读、搜索、调研——但在你批准之前不会修改任何内容。它会列出大纲方法、提出澄清问题并列出将要触及的文件。
你可以在一句话中发现错误的假设，而不是在四十个文件中。这一个习惯能大幅减少返工。
> 08. 把 Claude 当作初级开发者对待。
不要说“写一个做 X 的函数”，而是问“我们应该如何处理 X？有哪些权衡取舍？”先通过推理解决问题，比通过命令匹配模式能产生更好的代码。你也能了解它的假设，而那正是真正隐藏 Bug 的地方。
> 09. 让 Claude 提问。“直到你有 95% 的把握。”
在任何非 trivial 的请求后加上这句：“不断问我问题，直到你有 95% 的把握理解我需要什么以及你要做什么。”三轮澄清总是胜过三轮返工。这在计划模式（技巧 7）中尤其有效。
> 10. 将自检步骤烘焙到待办清单中。
当 Claude 制作待办清单时，让它将验证步骤作为实际项目加入：“截个图。打开开发者工具检查错误。运行测试。”
加上这句神奇的话：“在你有 95% 的把握当前项完成之前，不要进入下一个待办。”你不再会收到那些看起来做完实则未完的功能。
## 第二部分 · 控制
> 11. 部署子智能体进行并行工作。
告诉 Claude 在复杂任务中“使用子智能体”。每个子智能体拥有自己的上下文窗口，可以使用不同的模型，并并行工作——调研、测试、探索。它们向主会话汇报。
与模型分层（技巧 15）搭配，在主线程保持在 Opus 上的同时，在廉价的 Haiku 上运行子智能体。
> 12. 构建自定义技能。Markdown 中的可复用工作流。
在 .claude/skills/<name>/ 中放入一个 SKILL.md 文件，当任务匹配描述时，Claude 会自动加载它。一个技能就是前置数据 + markdown 指令——但因为它是即时加载的（休眠时约 100 token，需要时约 5K），你可以安装几十个而无需承担上下文成本。
> 13. 使用钩子处理必须执行的事件。
钩子是在特定事件自动触发的 Shell 脚本：PreToolUse、PostToolUse、会话开始/停止、子智能体完成。它们在模型推理之外运行，因此无法被跳过。用于：编辑时格式化、阻止危险的 bash 命令、提交前运行 Linter。
> 14. 编辑权限以实现安全自治。
不要使用 --dangerously-skip-permissions 进行 YOLO 操作。使用 /permissions 命令（或 ~/.claude/settings.json）显式允许安全命令并拒绝破坏性命令。
拒绝规则优于允许规则，因此即使通用的允许规则匹配，危险模式也会被阻止。同样的速度，零危险。
> 15. 根据任务匹配模型。Opus、Sonnet、Haiku——有的放矢。
直接在会话内切换：/model opus 用于架构设计和棘手的调试，/model sonnet 用于日常构建，/model haiku 用于廉价探索，如“找到所有导入 X 的文件”。所有事都用一个模型，是在浪费能力或金钱。
> 16. 使用 /memory 内联编辑 CLAUDE.md。
当你意识到某个约定应该永久保留时，运行 /memory 就地打开 CLAUDE.md。这比 Alt-Tab 切换到编辑器更快，而且更改会立即加载到本次会话的余下部分。
> 17. 运行 /review 进行内置代码审查。
/review 是一个内置技能，它会对你的最近更改进行结构化的审查——安全性、风格、边缘情况。比询问同事更快，并且能捕捉到原始会话因处于构建模式而非审查模式而遗漏的问题。
> 18. 使用 /cost 追踪开销。了解每次会话的成本。
/cost 显示当前会话的 Token 使用量和美元成本。用于找出哪些会话在悄悄烧钱（通常是：MCP 服务器太大、上下文太长）。与状态栏（技巧 2）搭配，使其始终可见。
> 19. 按 Esc Esc 回溯。会话的撤销按钮。
双击 Escape，Claude 会回溯到对话中的前一个点。当会话跑偏时至关重要——不用与它对抗或从头开始，只需回溯到跑偏之前并重新表述。大多数用户甚至不知道这个功能的存在。
> 20. 输入 # 进行快速记忆固定。无需离开即可添加到 CLAUDE.md。
以 # 开头的任何行，Claude 都会将其视为记忆指令——它会将文本添加到 CLAUDE.md 而不打断你的流程。非常适合在你意识到规则的瞬间捕获它：# 始终使用命名导出，绝不使用默认导出。
## 第三部分 · 规模
技巧 21-32 —— Claude Code 作为一个平台。包括 5 月 28 日的新功能。
> 21. 使用 git worktrees 运行并行会话。 --worktree feature-name。
自 Claude Code v2.1.50 起原生支持。在同一仓库上运行两个 Claude 会话而互不干扰：
每个工作树都是一个拥有自己工作目录的隔离分支。三个 Claude 会话，三个分支，零冲突。完成后像合并任何 git 分支一样合并回来。
> 22. 使用 API 端点代替 MCP。
MCP 会将服务器的所有工具定义加载到上下文中——典型的 5 服务器设置在你说话前就能吃掉 55K Token。如果你只需要一件事（例如读取一个 Notion 数据库），只需硬编码 API 端点。灵活性较差，但便宜得多。探索时用 MCP，生产环境用硬编码。
> 23. 使用 /loop 处理循环任务。
需要 Claude Code v2.1.72+。/loop 5m check the deployment status 会在同一会话内每五分钟重新运行提示词。非常适合盯着部署、观察 PR、轮询构建。循环是会话作用域的，为安全起见会在 3 天后自动过期。
> 24. 调度桌面任务。
对于超过会话时长的自动化，请使用 Claude Desktop 的定时任务功能。每次触发都会打开一个全新的会话（与之前的运行不共享上下文），但它能在终端关闭和笔记本重启后存活。用于：晨间问题分类、每周指标拉取、夜间日志扫描。
> 25. 使用 Routines 实现关机自动化。
Routines 在 Anthropic 的基础设施上运行——你的笔记本电脑可以关机。通过 API 调用、GitHub 事件或固定的 cron 计划例程。
与子智能体搭配实现连贯的夜间工作：“审查昨天的 PR，总结，早上 8 点发布到 Slack。” 这是异步团队缺失的编排层。
> 26. 从手机控制会话。
在本地启动会话，用手机扫描二维码，从任何地方继续引导它。你的代码永远不会离开你的机器——只有控制通道移动化。用于：在桌面上启动繁重的任务，在散步时监控，在健身房批准权限。
> 27. 针对难题使用 UltraThink。
在你的提示词中输入“ultrathink”，Claude 会在响应前分配最大的扩展思考预算。不要用于琐碎的修复——但对于架构决策、复杂调试或触及整个系统的重构，质量的提升是真实可见的。Token 成本更高；不使用它的代价更高。
> 28. 构建智能体团队。互相沟通的子智能体。
子智能体（技巧 11）隔离工作。智能体团队让它们共享任务清单、相互沟通并分配工作。你可以直接与任何团队成员对话，而不是通过主智能体路由。更昂贵，运行时间更长——但对于大型多领域项目，这种连贯性是值得的。
> 29. 安装 Context7 MCP。任何库的最新文档。
Claude 的训练数据有截止日期，因此它可能建议过时的 API。Context7 MCP 会在 Claude 编写任何代码之前，注入数千个库的最新、特定版本的文档——React、Next.js、Postgres，应有尽有。一次安装，提升所有库的质量。
> 30. 浏览 /plugin 市场。预构建的技能和智能体。
插件市场充满了预打包的技能、智能体和命令，你可以安装它们而不必自己编写。Context7（技巧 29）就是一个例子。构建之前先浏览——很可能已经有人发布了你需要的东西。
> 31. 触发动态工作流。最多并行 1,000 个子智能体。
两天前随 Claude Opus 4.8 一起发布。动态工作流让 Claude 能够处理一个会话无法完成的巨大任务，进行规划，分散到最多 1,000 个并行子智能体，运行第二波智能体来反驳每个发现，迭代直到结果一致，然后交付综合后的答案。
编排计划存在于 Claude 即时编写的 JavaScript 脚本中——不在上下文窗口中——这就是为什么 500 智能体的运行成为可能。激活只需要一个关键词：
需要 Claude Code v2.1.154+。Max 和 Team 版本默认开启；Enterprise 管理员启用；Pro 用户在 /config 中手动开启。通过说“create a workflow”或将 effort 设置为 ultracode（下一个技巧）来触发。
上限：每个工作流 1,000 个子智能体。成本：显著高于单智能体运行——仅在任务规模合理时使用。
> 32. 设置 /effort ultracode。Claude 决定何时发散。
动态工作流的伴侣。/effort ultracode 将推理级别设置为 xhigh，并让 Claude 自动决定任务何时大到足以启动工作流。单个请求可以变成顺序的多个工作流——一个用于理解代码，一个用于应用更改，一个用于验证。
会话作用域：它会一直开启，直到你更改或开始新会话。对于日常工作降回 /effort high，因为 ultracode 消耗的 Token 远多于标准会话。Anthropic 官方建议：与自动模式搭配，以免并行子智能体被权限提示阻塞。
## § 让新手停滞不前的习惯
- 没有 CLAUDE.md。每次都重新解释项目，每次都得到错误的答案。
- 从不检查 /context。你无法修复你看不见的臃肿。
- 跳过计划模式。为了修复一句话的误解而修改四十个文件。
- YOLO 权限。速度很棒，直到 rm -rf 在错误的目录运行。
- 所有事都用一个模型。在 Haiku 任务上燃烧 Opus Token。
- 忽略市场。构建已作为插件存在的技能。
- 不知道本周发布了什么。最大的功能（动态工作流、ultracode）通常悄悄发布。
## 结语：
Claude Code 之所以变好，不是因为单一功能。它变好是因为三十二个功能叠加——CLAUDE.md 提供上下文，计划模式捕捉假设，Skills 打包工作流，Hooks 强制规则，Worktrees 并行化，MCP 连接，动态工作流编排一千个智能体。每一个都有帮助。组合起来改变了可能性。
大多数人会使用其中的 6 个，在它出错时责怪 Claude，然后离开。今天那 4% 提交代码的人是那些不断叠加使用的人。
选择一个你没用过的技巧——可能是 /init 或计划模式——明天就用上。然后再下一个。新手和 PRO 之间的差距正是这份清单的应用。
## 相关链接
- [Codez](https://x.com/0xCodez)
- [@0xCodez](https://x.com/0xCodez)
- [57K](https://x.com/0xCodez/status/2060723834617999592/analytics)
- [movez.substack.com](https://movez.substack.com/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [10:03 PM · May 30, 2026](https://x.c