Foundations Module 5 · Cheat Sheets (Reference)

Vibe Coding Reference

Last reviewed

Beginner

What you'll learn

~15 min
  • Understand what vibe coding means and when it's appropriate
  • Activate planning mode in each CLI tool
  • Know the safety spectrum from throwaway prototypes to production code
  • Set up project memory files so the AI remembers your conventions

By the end of this lesson, you will have a reference for every power feature across the four CLI tools we teach — planning modes, autonomous modes, thinking levels, context management, and project memory. Bookmark this page and come back whenever you need to look something up.

💡How to use this cheat sheet

Bookmark this page. These commands and modes are your toolkit — copy them into your terminal when you need them. Come back whenever you need a quick reference.

⚠This is a reference page — you'll use it later

This cheat sheet covers commands you’ll learn in Module 6 (Your Agent In Depth) and Module 7 (Git). If you’re working through the course in order, bookmark this page now and return after Module 7. The commands below won’t work until you’ve installed your tools and initialized Git.

Already set up? Use this as your daily reference.

What is vibe coding?

Andrej Karpathy coined the term in February 2025: “fully give in to the vibes, forget that the code even exists.” You describe what you want, the AI writes the code, and you accept the results based on whether the output feels right — without necessarily reading every line.

Simon Willison drew an important distinction: vibe coding is for throwaway prototypes where you do not review the code. Vibe engineering is for production work where you are accountable for every line the AI writes.

ℹBoth are valid

Vibe coding a weekend prototype? Go fast, skip the review. Building something your team or users depend on? Slow down, read the code, test it properly. The tools and modes below support both workflows — the difference is how much you review and how much autonomy you grant.

Tool modes at a glance

This table shows how each tool opens, runs with approval prompts off, and plans, and other lessons link here for the details. Open the tool, then switch to plan mode inside the session; the launch flags in the last column are there for reference.

Practice sessions in this course start the tool with approval prompts off. The domain tracks’ setup lessons do the same, and in Module 14 your agency’s rules decide. With prompts off, the tool can change anything your account can reach, not only the files in your practice folder. Keep real files out of the folder you start it from, and remember that a commit restores the files in that folder, not anything a command changed elsewhere. Each vendor describes the mode in its own terms, summarized in the table. To be asked more often, start the tool with just its name.

How each tool opens, runs with approval prompts off, and plans. Checked on 19 November 2026 with Claude Code 2.1.329, Codex CLI 0.170.0, GitHub Copilot CLI 1.0.114 and Antigravity CLI 1.5.13, against each tool's help and documentation; the Copilot steps were also tried in a live session. These steps have not been tried on Antigravity CLI. If your tool behaves differently, its own --help has the last word.
Tool Open itApproval prompts off (this course)Plan mode, inside the sessionLeave the toolReference: launch flags
Claude Code claude

Starts in Auto mode: a separate classifier reviews risky steps before they run, and routine edits go through.

claude --dangerously-skip-permissions

Skips every permission check: edits and commands run without asking, inside or outside the folder. Deny rules you have set still block. Anthropic documents this mode for isolated containers and VMs without internet access.

Press Shift+Tab until the status bar says plan, or start a message with /plan.

How firmly it waits: Started with approval prompts off, plan mode is an instruction, not a lock: Claude is told not to edit while planning, but an edit or command it tries runs without asking, and a one-time note says so. Started plainly, plan mode blocks edits.

Leave plan mode before you say go ahead? No. When the plan is ready it asks whether to go ahead, and you pick from its list.

Type /exit, or press Ctrl+D twice. Ctrl+C twice on an empty prompt also leaves.

claude --permission-mode plan

Starts the tool already in plan mode. Listed for reference; this course opens the tool plainly and switches inside.

Codex CLI codex

In a Git folder, starts in Auto: it writes inside the folder, decides for itself when to ask before other commands, and keeps the network off. In other folders it starts read-only.

codex --dangerously-bypass-approvals-and-sandbox

Skips every confirmation prompt and also turns off the sandbox, so commands run without approval and outside the folder. OpenAI documents it only for environments that are sandboxed or hardened from outside, and suggests newcomers start with the default permissions.

Type /plan (with or without a request after it) or press Shift+Tab.

How firmly it waits: In plan mode Codex is told to read and plan without changing files. That is an instruction to the model, not a lock, so read the plan before you let it build.

Leave plan mode before you say go ahead? Yes. A request to build sent in plan mode is taken as a request to plan the build, so turn plan mode off (/plan or Shift+Tab) first, then say go ahead.

Type /exit or /quit.

None that we found. Open the tool, then switch inside.

GitHub Copilot CLI copilot

In its Manual Approval mode it asks before a tool, file path or web address you have not allowed; /permissions show tells you which approval mode it is in. On first start in a folder it asks whether to trust the folder.

copilot --allow-all

Turns on every permission at once: tools, file paths and web addresses, without asking. It still asks the folder-trust question on first start. GitHub notes that automatic approval can allow destructive operations without individual prompts, and suggests considering a sandbox first.

Press Shift+Tab (one press from the normal mode shows Plan at the bottom of the screen), or type /plan.

How firmly it waits: Plan mode blocks the built-in tools that would change your files.

Leave plan mode before you say go ahead? No. Say go ahead while it is still in plan mode and it offers "Accept plan and continue"; pick that and it builds.

Type /exit.

copilot --plan

Starts the tool already in plan mode. Listed for reference; this course opens the tool plainly and switches inside.

Antigravity CLI agy

Starts in default mode: it pauses to show each file change for your review and asks before commands and network calls. Auto mode, which approves more on its own, is one of the modes Shift+Tab cycles through on personal accounts.

agy --dangerously-skip-permissions

Approves every tool permission request without asking, including file writes and commands. Deny rules still take precedence, commands on the system denylist stay blocked, and a plan still waits for your review. Google suggests scoped permissions.allow rules unless you fully trust the prompt and environment.

Press Shift+Tab until the status bar says plan, or type /plan before a message.

How firmly it waits: In plan mode it outlines the steps and waits for your approval before writing code; the skip-permissions flag does not approve that outline for you. Its documentation does not say whether edits are blocked while it plans.

Leave plan mode before you say go ahead? It shows the outline and waits for your approval. If a typed go-ahead does nothing, choose the approval the tool shows.

Press Ctrl+D with the prompt empty. Closing the terminal window also ends it.

agy --mode=plan

Starts the tool already in plan mode. Listed for reference; this course opens the tool plainly and switches inside.

ℹVersion note

Tool behavior and commands evolve between releases. If a command doesn’t work as shown, run <tool> --help or /help to check your installed version. Not all commands exist in all versions.

Planning modes

Planning modes let the AI read your project and propose a strategy before it builds. Switch to plan mode inside a running session: Shift+Tab until the status bar says plan, or /plan, in all four tools. How firmly each tool waits differs: the plan-mode column of the table above says what each one does, including what changes when approval prompts are off.

Autonomous / YOLO modes

These modes let the AI execute tasks with minimal or no confirmation. Useful for speed; risky if you are not careful.

Autonomous Modes

Maximum-speed execution with minimal confirmation

ToolCommandSafety netWhat it skips
Claude Codeclaude --dangerously-skip-permissionsDeny rules in permissions.deny still block; everything else runs unasked. Anthropic documents it for isolated containers and VMs without internet accessFile edit confirmations, command approvals
Antigravity CLIagy --dangerously-skip-permissionsOptional OS sandbox with --sandbox; since CLI 1.5.2, system-denylist commands stay blocked (per agy changelog)File and command confirmations
Codex CLIcodex --dangerously-bypass-approvals-and-sandbox (the start this course uses), or codex -a never -s workspace-write to skip confirmations but keep the sandboxNone with the first; with the second, the OS sandbox keeps writes inside the projectAll confirmations, and with the first, the sandbox too
Copilot CLIcopilot --allow-all (the same as --yolo: all tools, file paths, and web addresses), often with --mode autopilot so it keeps going between steps; --allow-all-tools covers tools onlyDeny rules still win; --max-ai-credits sets a soft cap on spend (minimum 30 AI credits)Tool, file path, and web address confirmations
ℹHow this course uses them

Practice sessions in this course start with approval prompts off; Tool modes at a glance says what that does and does not protect. The vendors put it differently. Anthropic documents its flag for isolated containers and VMs without internet access. OpenAI documents its flag for environments sandboxed or hardened from outside, and suggests newcomers start with the default permissions. GitHub suggests considering a sandbox before granting wide permissions. Google suggests scoped permissions.allow rules unless you fully trust the prompt and environment. To be asked more often, start the tool with just its name. Either way, commit first so you have a version to go back to.

ℹWhen NOT to vibe code
  • Code that handles PII (personally identifiable information), financial data, or credentials
  • Production deployments or anything users depend on
  • Security-sensitive logic (authentication, authorization, encryption)
  • Code that runs with elevated privileges (sudo, admin, root)
  • Anything your team, employer, or agency holds you accountable for

In these cases, switch to plan mode, review diffs carefully, and test before shipping.

🧬In Your Field: Biotechclick to expand

Keep research data out of any session started with approval prompts off. A single misplaced rm -rf can wipe out months of sequencing results, and the tool can reach any folder your account can. Work in a fresh directory that holds only sample or copied data (mkdir experiment && cd experiment), keep your data directories backed up, and run git init and git commit -m "pre-AI" before each task so you can revert changes inside that folder.

🏛️In Your Field: Government Devclick to expand

Keep PII (personally identifiable information) and production systems out of any session started with approval prompts off. Government data has legal protections. On agency work, your agency’s tool and approval rules come first (Module 14, Lesson 1); start a tool with prompts off only in an isolated development environment with synthetic test data. If your agency has a sandbox environment, use it.

Thinking and effort levels

Some tools let you control how deeply the AI thinks before responding. Higher effort = slower but more thorough.

Thinking & Effort Levels

Controlling how deeply the AI reasons

ToolCommandLevelsWhen to use
Claude Code/effortlow · medium · high · xhigh · maxDefaults vary by model; Opus, Sonnet, and Haiku 5.5 default to medium. Low for quick edits, xhigh/max for the hardest problems
Antigravity CLI/effort in a session or --effort at launch (levels depend on the model; /model picks the model)low · medium · high on Gemini 4 Carbon, Gemini 4 Argon and Gemini 3.8 Flash; Gemini 4 Neon and Gemini 4 Hydrogen add Extra (--effort xhigh) and default to High (--effort accepts up to max). The Antigravity desktop app offers the same models and effort choicesPick a lighter Flash model at low effort for simple tasks to save quota
Codex CLI/model (sets model + effort)low … xhigh · max, plus ultra on every current Codex model except LunaStart at your client’s default effort (OpenAI suggests Light, low, for Astra and High for Luna); ultra hands parts of the task to parallel subagents, so it uses your window faster
Copilot CLI--reasoning-effort at launch; /model to pick the modelnone … maxLeave the default for routine work; raise it for a hard debugging or design task
💡Match effort to task

Asking the AI to “rename this variable” does not need max effort. Asking it to “redesign the authentication system” does. Adjusting effort saves time on simple tasks and improves quality on hard ones.

Context management

These commands keep a conversation focused: one task per conversation, a fresh start between tasks, and a way back to earlier work.

Context Management

Keeping conversations focused and efficient

CommandToolWhat it does
/compactClaude Code, Codex CLI; Antigravity (changelog only); Copilot not verifiedCondenses conversation history; add what to keep
/clearAll four (Codex and Antigravity also accept /new)Starts a fresh conversation
/resumeAll fourPick an earlier session to continue
/usageAll fourShows usage; Copilot /limits manages session limits
/rewindClaude Code: code, conversation, or both, but not changes made by shell commands. Antigravity: the conversation; whether files roll back is not documented. Copilot: listed in help; what it restores is not documented. Codex: noneStep back to an earlier in-session checkpoint; commit first in every tool
/modelAll fourSwitch to a different model mid-session
/permissionsAll fourChange what runs without asking (Codex: switch permission profile)
/initClaude Code, Codex CLI, Copilot CLIGenerate a project memory file (CLAUDE.md, AGENTS.md, or copilot-instructions.md)

Review, resume, and more

The everyday controls beyond plan mode, per tool. A blank capability is written as “none” or “not verified” rather than left out.

Review, Speed, and More

One row per control, one column per tool

ControlClaude CodeCodex CLIAntigravity CLICopilot CLI
Built-in review/code-review (/review is the same); /security-review/review (base branch, uncommitted, commit, or custom)/diff viewer, then a review prompt; no review command/review, /security-review
Resume from the shellclaude --continue, claude --resumecodex resume --last, or codex resume to pick oneagy --continue, agy --conversation <id>copilot --continue, --resume
Side question (/btw)YesYesYesNot verified
Work until a check passes (/goal)YesYesYesNot verified
Editor connection/ide/ideEditor extensions, agy acp/ide
Fast mode/fast: GA on Opus 5.5; Opus 4.8 fast mode errors as of 2026-11-30/fast (Fast service tier)Removed in v1.1.0Not verified
Scheduled runs/loop in session; cloud /schedule is a research previewDesktop app only, not the CLI/schedule/every, /after: experimental

Fast mode costs more per token than standard speed (Claude Code; OpenAI’s pricing lists Fast at 2x); before 2026-11-30, Opus 4.8 fast mode still works with a deprecation notice. The portable scheduler is a headless run from cron or CI (Module 19’s headless lesson: the same prompt, run unattended).

Real Session Workflow

This is the course’s one loop, plan, approve, build, check, keep, as experienced practitioners run it: not one-shot commands, but a cycle of thinking and building. Choosing your surface is Module 3, the command line is Module 4, and this reference is Module 5.

Session Lifecycle

The practical cycle for real work

StepWhat you doKey commands
LaunchStart Claude Code in your project directoryclaude --dangerously-skip-permissions (approval prompts off, as this course starts practice sessions), or claude (Auto mode) to be asked more often
1. PlanEnter plan mode, describe the goal in one or two sentences, answer the agent’s questionsShift+Tab or /plan
2. ApproveRead the plan and approve it, or ask for changesShift+Tab to leave plan mode
3. BuildLet the agent build, one piece at a time
4. CheckOpen the result, and run the built-in review on your changes; fix the justified findings/code-review
5. KeepAsk the agent to save a checkpoint before the next piece (Module 7)“Save a checkpoint called …”
TidyCompact at a boundary, clear when switching tasks, resume later/compact <what to keep>, /clear, claude --continue

Then back to plan for the next piece.

The build loop: The back-and-forth between plan mode and execute mode IS the skill. You plan in plan mode, approve, build in execute mode, check, keep a checkpoint, and repeat. At a phase boundary, /compact with a note of what to keep preserves those decisions. When you’re starting a completely new task, /clear gives you a fresh start, but save a checkpoint first.

Where --dangerously-skip-permissions fits: it removes the confirmation prompts; deny rules in permissions.deny still block. Anthropic documents it for isolated containers and VMs without internet access (permission modes). This course starts practice sessions with it (what that does and does not protect). Started this way, plan mode is an instruction Claude follows, not a lock. To be asked more often, start with claude: Auto mode approves routine steps and stops for risky ones. The flag has no short alias.

Describe, don’t command: “I need a contact form with validation” beats “create a file called form.html with an input element.” Give context and intent — let Claude figure out the implementation.

Project memory files

Project memory files tell the AI about your project’s conventions, preferences, and structure before you say anything. They persist across sessions. The files below are commonly used conventions in this course — check each tool’s documentation for which files are officially auto-read vs. manually referenced.

Project Memory Files

Persistent instructions the AI reads automatically

FileToolWhat to put in it
CLAUDE.mdClaude Code (for an AGENTS.md: Claude Code reads it directly when the project has no CLAUDE.md (v2.1.277 and later); if it has one, add the line @AGENTS.md to it so it loads too.)Build and test commands, conventions, the rules the code cannot tell it
.github/copilot-instructions.mdGitHub Copilot (also reads AGENTS.md, CLAUDE.md, and GEMINI.md)Coding standards, architecture notes, naming conventions
GEMINI.md or AGENTS.mdAntigravity CLI (loads both, every rule it finds, with no precedence order; /learn proposes a rule)Project context, style preferences, domain-specific notes
AGENTS.mdCodex CLI (and the cross-tool convention; Codex reads a global ~/.codex/AGENTS.md and the file closest to your folder wins, up to 32 KiB)Project overview, conventions, what to avoid
💡Start with /init

In Claude Code, Codex CLI, or Copilot CLI, type /init and the AI reads your project and generates a starter memory file (CLAUDE.md, AGENTS.md, or Copilot’s custom instructions). Antigravity has no /init; its /learn proposes a rule from the session. It is the fastest way to get started with project memory. Review the generated file and edit it to match your preferences.

📊In Your Field: MIS / Businessclick to expand

Put your business conventions in memory files. If your department uses specific naming conventions (camelCase for API fields, snake_case for database columns), date formats (ISO 8601 vs MM/DD/YYYY), or reporting standards, add them to your project memory file. The AI will follow them in every session without you having to repeat yourself.

MCP (Model Context Protocol)

All four CLI tools now support MCP — a standard protocol that lets AI tools connect to external services (databases, APIs, documentation servers, etc.) through plug-in “servers.” You configure MCP servers in your project config, and the AI can call them during a session.

ℹMCP is an advanced topic

You will not need MCP for the core modules. It is mentioned here so you know the capability exists. When you’re ready, MCP: Extending Your Agent covers connecting and vetting servers.

Context window management

Your context window is like a desk: one task on it at a time is easier to work with. Claude Code compacts long conversations on its own, and Anthropic’s best practices now list context-window anxiety under “What you can stop doing”, so treat clearing and compacting as hygiene, not rescue.

Rule of thumb: one task per conversation. A focused conversation usually beats a sprawling one.

When to Clear vs. Compact

Keep your context clean for better results

ActionWhen to use it
/clearBetween unrelated tasks, after a commit. After two failed corrections on the same issue.
/compactAt a phase boundary, naming what to keep: /compact keep the schema decisions and the open TODOs.
Start freshAI repeating itself. Switching codebase areas. Resume the old session later if you need it.
Keep goingMid-task with good results. Iterating on the same piece.

What Survives Clearing

You never lose your work — these persist automatically

LayerClaude CodeAntigravity CLICodex CLICopilot CLI
Project memoryCLAUDE.mdGEMINI.md or AGENTS.mdAGENTS.md.github/copilot-instructions.md or AGENTS.md
Session resumeclaude --continue or /resumeagy --continue or /resumecodex resume --last or /resumecopilot --continue, --resume, or /resume
Git stateReads status/diff/logSimilarSimilarSimilar
Plan filesSaved by the tool (check /help)Conversation artifactsN/ANot verified
Auto-memoryOn by default; toggle in /memoryNone by design; /learn proposes a rule you review/memories (a recall layer; keep rules in AGENTS.md)/memory (--enable-memory)

Best practices:

  1. One task, one session. Build, commit, clear, move on. The single most impactful habit.
  2. Commit before you clear. Git is your permanent save. Conversation is temporary.
  3. Use plan mode for complex work. Natural breakpoints for clearing between phases.
  4. Save state before clearing. Ask the AI to summarize progress, then add it to your project memory file.
  5. Use /btw for throwaway questions (Claude Code, Codex, and Antigravity; not verified in Copilot). It sees the conversation but stays out of its history.
  6. Delegate independent work to subagents. Use them for parallel research, for keeping noisy output out of your way, and for an independent review; see Subagents & Orchestration.

The safety spectrum

Not every project needs the same level of caution. Use this spectrum to decide how much autonomy to grant:

Safe to vibe code Always review carefully
| |
v v
Throwaway Learning Internal Production
prototype exercise tool / public-facing
| | | |
YOLO mode Auto-edit Plan first Plan mode +
Don't read Skim output Review diffs read every line
the code
KNOWLEDGE CHECK

Your team asks you to build a quick prototype to demo an idea at tomorrow's meeting. Nobody will use this code after the demo. Which approach is most appropriate?

When things go wrong

Quick recovery commands when the AI makes a mess:

ProblemRecovery
AI changed files you didn’t want changedgit status and git diff to see what changed, git restore --staged --worktree <file> to put a file back to the last commit (new files stay until you delete them)
Want the tool’s own undo/rewind where it exists; the Context Management table says what each tool’s version restores
Need to revert the last commitgit reset --soft HEAD~1 (keeps changes staged for review)
Command is hangingPress Esc to stop the current action (or Ctrl+C)
AI is going off-trackType /clear and restate your goal in 1-2 sentences
Context is getting staleAt a natural boundary, /compact with a note of what to keep (Claude Code, Codex), or /clear and restate the goal
Not using Git yetRestore from your last manual backup or snapshot
🔧

When Things Go Wrong

Use the Symptom → Evidence → Request pattern: describe what you see, paste the error, then ask for a fix.

Symptom
You enabled YOLO/autonomous mode and the AI deleted or overwrote important files
Evidence
Files are missing or overwritten after running in autonomous mode
What to ask the AI
"I ran my CLI tool in autonomous mode and it deleted/overwrote files I needed. How do I recover? I was using git -- can I restore from my last commit? And how do I prevent this next time?"
Symptom
The AI keeps forgetting project context mid-conversation
Evidence
The AI suggests changes that contradict decisions from earlier in the conversation
What to ask the AI
"My conversation is getting long and the AI is forgetting context from earlier. Should I use /compact to condense the history, or start a new session? How do I preserve the important decisions?"
Symptom
Project memory file is outdated and the AI follows stale conventions
Evidence
The AI keeps using patterns you've moved away from, citing CLAUDE.md or similar
What to ask the AI
"My CLAUDE.md file has outdated information and the AI keeps following old patterns. How do I update it? Can I ask the AI to regenerate it based on the current project state?"

Common workflows

Prototype flow:

  1. mkdir prototype && cd prototype && git init
  2. Start your AI tool as the tool modes table shows (with just its name if you want to be asked more often)
  3. Switch to plan mode, describe what you want, and read the plan before you tell it to build.
  4. Test the output. If it works, git add . && git commit -m "working prototype".

High-risk task flow:

  1. Activate plan mode (/plan or Shift+Tab)
  2. Review the AI’s proposed plan
  3. Approve step by step, checking diffs along the way
  4. Test thoroughly before committing

Long session rescue flow:

  1. Run /compact with a note of what to keep (Claude Code and Codex; elsewhere check /help)
  2. If quality is still poor, try /model to switch models
  3. If context is completely lost, /clear and restate your goal from scratch

Key takeaways

  • Vibe coding = speed over review for throwaway work. Vibe engineering = same tools but you read every line. Both are valid depending on the stakes.
  • Planning modes (Shift+Tab, /plan) let the AI analyze before acting. Use them for any non-trivial task.
  • Approval prompts off is how this course starts practice sessions. The tool can then reach anything your account can, so keep important data, research files and production systems out of those sessions, and commit first.
  • Clear, compact, and resume are hygiene. /clear between unrelated tasks, /compact with a note of what to keep at a boundary, and resume to come back later.
  • Commit first, then the tool’s undo. Git covers every change; /rewind covers only what each tool recorded, and Codex has none.
  • Review before you commit. /code-review in Claude Code, /review in Codex and Copilot, /diff plus a review prompt in Antigravity.
  • Project memory files (AGENTS.md, CLAUDE.md, GEMINI.md, .github/copilot-instructions.md) persist across sessions. Start with /init (Claude Code, Codex, Copilot) and customize from there.
  • Ready to go deeper? Module 19: Agentic Engineering covers MCP, skills, hooks, multi-agent orchestration, and headless/CI pipelines.
Search lessons