32 Tricks to Level Up Claude Code in 16 Mins

Beginner Cloudcode hacks (11–20)

1. Run /init on every project

   • Scans the entire codebase and generates a cloud.md file that acts like a project cheat sheet (architecture, conventions, key files).
   • For new projects, you can describe goals/stack/rules and Cloudcode can generate cloud.md.

2. Set up a status line (/status line)

   • Creates a small terminal dashboard showing session details like model, context %, and cost.
   • Helps avoid running out of context (“context rot”).

3. Voice input

   • Uses a native /voice command (rolling out) or external voice apps.
   • Lets you talk to the terminal and have Cloudcode write code.

4. Keep context small

   • Don’t dump the whole repo into the conversation—provide only what’s needed.
   • Break big problems into smaller steps so Cloudcode gets less “noise” and performs better.

5. Use /context to find token bloat

   • Shows exactly what’s consuming tokens (system prompts, file contents, MCP servers, etc.) as percentages.
   • Use it to diagnose and restructure.

6. Use /compact and /clear

   • When context reaches ~60%, run /compact to compress history.
   • Can preserve specific important items (e.g., API integration decisions, DB schema).
   • Use /clear to wipe conversation history when switching tasks, while still keeping cloud.md and files.

7. Start in plan mode

   • Plan mode (cycled via Shift+Tab) lets Cloudcode read/research but not modify code.
   • It outlines steps + asks clarifying questions first; then you switch to execute for better quality.

8. Treat Cloudcode like a junior developer

   • Prefer framing the problem (“How should we handle growth tracking?”) over direct “write X” commands.
   • Encourages reasoning and better explanations.

9. Make Cloud ask questions

   • Use an “ask user questions” tool until it’s ~95% confident it understands requirements.

10. Add self-checking into the to-do list

    • Build verification steps directly into the workflow (e.g., screenshot the built website; check Chrome DevTools for errors).
    • Use a threshold like: “don’t move on until 95% confident.”

11. Sub-agents for parallel work (advanced-ish progression)

    • The main agent spawns isolated sub-agents with their own context windows.
    • Sub-agents can research, write tests, explore approaches in parallel, then report back.
    • Can pair with cheaper-model usage (e.g., sub-agents on Haiku, main on Opus).

12. Custom skills

    • Reusable prompt workflows stored in .cloud/skills/ (e.g., techdebt.md, codereview.md).
    • Invoked via natural language or a command; can be shared with teams via GitHub.

---

Mid/advanced productivity & cost hacks (13–22)

1. Use Haiku for sub-agents

   • For large/cheap processing (scraping many articles, summarizing huge inputs), use Haiku to reduce cost while keeping high-quality outputs for the main agent.

2. Continuously refresh cloud.md

   • Update it when you learn new project conventions, gotchas, or create new skills.
   • Keep cloud.md lean (target ~150–200 lines) because it loads into every conversation and consumes context.

3. Route cloud.md to other files

   • Instead of bloating cloud.md, link to separate reference/style/business context docs.
   • Saves tokens while still giving Cloudcode pointers to where the info lives.

4. Exit early and re-ask

   • If Cloud is going the wrong way, press Escape, correct, and re-prompt.
   • Avoid wasting context on the detour.

5. Challenge outputs aggressively

   • If output is “okay,” push back (“more elegant,” “different approach”).
   • After improvements, update the skill or cloud.md so the same mistake doesn’t repeat.

6. Use /rewind

   • Quick undo: rolls back to a previous point in the conversation without restarting.

7. Use hooks for notifications

   • Configure notification hooks (e.g., a sound when a session finishes).
   • Useful for managing many simultaneous Cloudcode sessions.

8. Use screenshots

   • Cloud can “see” screenshots to analyze UI/layout and error states.
   • Supports self-check loops: design → screenshot → evaluate → iterate (multiple passes before V1).

9. Use Chrome DevTools

   • Cloud can operate a browser to validate app behavior and UI interactions (buttons, forms).
   • Potentially can handle workflows requiring manual navigation/clicking (and maybe reCAPTCHAs if already authenticated—though the speaker notes this is probabilistic and better when signed in).

10. Clone inspiration sites

    • Use screenshots and tell Claude “make it look like this” to recreate design patterns.
    • Optionally feed HTML/styling snippets as references to avoid generic AI-looking results.

---

Advanced engineering/automation & infrastructure (23–32)

1. Run parallel sessions with Git work trees

   • Uses git work tree to run multiple isolated branches/sessions simultaneously in one repo without overwriting.
   • Merge branches back afterward.

2. Prefer API endpoints over MCP servers (sometimes)

   • MCP servers may load many tool definitions into context.
   • If you only need a small subset (e.g., read one Notion database), call the direct API endpoint to save tokens.

3. Use /loop for recurring tasks

   • Schedule prompts like “every 5 minutes check deployment.”
   • Loops run for about 3 days; longer-term automation requires desktop scheduled tasks (which spawn separate sessions with less context continuity).

4. Host on a VPS for always-on sessions

   • Keep Cloudcode running remotely even when your laptop is closed.
   • SSH in when needed; potentially interact via Telegram.

5. Remote control from your phone

   • Newer feature: steer local sessions from a mobile/browser controller.
   • Code stays local; you only control it remotely.

6. No-SQL data analytics via CLI tools

   • Connect CLI tools like BigQuery bq and ask natural language questions (e.g., “top 10 revenue sources last quarter”).
   • Claude translates to the appropriate query and returns results—no explicit SQL drafting needed.

7. “Ultra think”

   • Instruct Cloudcode to allocate a very large reasoning budget (~32,000 tokens).
   • Suggested for architecture decisions, complex debugging/refactors, or when outputs fail after a couple attempts.

8. Edit permissions for safer autonomy

   • Instead of “dangerously skip permissions,” explicitly allow safe commands and deny destructive operations (deny takes priority).

9. Agent teams

   • More coordinated than sub-agents: agents can talk to each other, share task lists, and assign work.
   • More expensive and longer-running, but better cohesion for big projects.

10. Context 7 MCP (version-specific documentation)

    • Install a Context 7 MCP server to pull up-to-date, version-specific technical docs for live libraries/frameworks.
    • Helps solve the training cutoff problem where Claude might suggest outdated/deprecated APIs.
    • Injects current docs before coding begins for improved accuracy.

---

Main speakers/sources (as presented in the subtitles)

• The video narrator/speaker (the same person throughout): “I” (no specific name given in the provided subtitles).
• Cloudcode / Claude Code (the product/tools being discussed).