Vibe Coding Reference
Last reviewed
BeginnerWhat 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.
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 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.
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.
| Tool | Open it | Approval prompts off (this course) | Plan mode, inside the session | Leave the tool | Reference: launch flags |
|---|---|---|---|---|---|
| Claude Code | claudeStarts in Auto mode: a separate classifier reviews risky steps before they run, and routine edits go through. | claude --dangerously-skip-permissionsSkips 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 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 | claude --permission-mode planStarts the tool already in plan mode. Listed for reference; this course opens the tool plainly and switches inside. |
| Codex CLI | codexIn 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-sandboxSkips 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 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 ( | Type | None that we found. Open the tool, then switch inside. |
| GitHub Copilot CLI | copilotIn its Manual Approval mode it asks before a tool, file path or web address you have not allowed; | copilot --allow-allTurns 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 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 | copilot --planStarts the tool already in plan mode. Listed for reference; this course opens the tool plainly and switches inside. |
| Antigravity CLI | agyStarts 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 | agy --dangerously-skip-permissionsApproves 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 | Press 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 | agy --mode=planStarts the tool already in plan mode. Listed for reference; this course opens the tool plainly and switches inside. |
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
| Tool | Command | Safety net | What it skips |
|---|---|---|---|
| Claude Code | claude --dangerously-skip-permissions | Deny rules in permissions.deny still block; everything else runs unasked. Anthropic documents it for isolated containers and VMs without internet access | File edit confirmations, command approvals |
| Antigravity CLI | agy --dangerously-skip-permissions | Optional OS sandbox with --sandbox; since CLI 1.5.2, system-denylist commands stay blocked (per agy changelog) | File and command confirmations |
| Codex CLI | codex --dangerously-bypass-approvals-and-sandbox (the start this course uses), or codex -a never -s workspace-write to skip confirmations but keep the sandbox | None with the first; with the second, the OS sandbox keeps writes inside the project | All confirmations, and with the first, the sandbox too |
| Copilot CLI | copilot --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 only | Deny rules still win; --max-ai-credits sets a soft cap on spend (minimum 30 AI credits) | Tool, file path, and web address confirmations |
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.
- 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
| Tool | Command | Levels | When to use |
|---|---|---|---|
| Claude Code | /effort | low · medium · high · xhigh · max | Defaults 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 choices | Pick 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 Luna | Start 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 model | none … max | Leave the default for routine work; raise it for a hard debugging or design 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
| Command | Tool | What it does |
|---|---|---|
/compact | Claude Code, Codex CLI; Antigravity (changelog only); Copilot not verified | Condenses conversation history; add what to keep |
/clear | All four (Codex and Antigravity also accept /new) | Starts a fresh conversation |
/resume | All four | Pick an earlier session to continue |
/usage | All four | Shows usage; Copilot /limits manages session limits |
/rewind | Claude 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: none | Step back to an earlier in-session checkpoint; commit first in every tool |
/model | All four | Switch to a different model mid-session |
/permissions | All four | Change what runs without asking (Codex: switch permission profile) |
/init | Claude Code, Codex CLI, Copilot CLI | Generate 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
| Control | Claude Code | Codex CLI | Antigravity CLI | Copilot 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 shell | claude --continue, claude --resume | codex resume --last, or codex resume to pick one | agy --continue, agy --conversation <id> | copilot --continue, --resume |
Side question (/btw) | Yes | Yes | Yes | Not verified |
Work until a check passes (/goal) | Yes | Yes | Yes | Not verified |
| Editor connection | /ide | /ide | Editor 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.0 | Not verified |
| Scheduled runs | /loop in session; cloud /schedule is a research preview | Desktop 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
| Step | What you do | Key commands |
|---|---|---|
| Launch | Start Claude Code in your project directory | claude --dangerously-skip-permissions (approval prompts off, as this course starts practice sessions), or claude (Auto mode) to be asked more often |
| 1. Plan | Enter plan mode, describe the goal in one or two sentences, answer the agent’s questions | Shift+Tab or /plan |
| 2. Approve | Read the plan and approve it, or ask for changes | Shift+Tab to leave plan mode |
| 3. Build | Let the agent build, one piece at a time | |
| 4. Check | Open the result, and run the built-in review on your changes; fix the justified findings | /code-review |
| 5. Keep | Ask the agent to save a checkpoint before the next piece (Module 7) | “Save a checkpoint called …” |
| Tidy | Compact 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
| File | Tool | What to put in it |
|---|---|---|
CLAUDE.md | Claude 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.md | GitHub Copilot (also reads AGENTS.md, CLAUDE.md, and GEMINI.md) | Coding standards, architecture notes, naming conventions |
GEMINI.md or AGENTS.md | Antigravity CLI (loads both, every rule it finds, with no precedence order; /learn proposes a rule) | Project context, style preferences, domain-specific notes |
AGENTS.md | Codex 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 |
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.
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
| Action | When to use it |
|---|---|
/clear | Between unrelated tasks, after a commit. After two failed corrections on the same issue. |
/compact | At a phase boundary, naming what to keep: /compact keep the schema decisions and the open TODOs. |
| Start fresh | AI repeating itself. Switching codebase areas. Resume the old session later if you need it. |
| Keep going | Mid-task with good results. Iterating on the same piece. |
What Survives Clearing
You never lose your work — these persist automatically
| Layer | Claude Code | Antigravity CLI | Codex CLI | Copilot CLI |
|---|---|---|---|---|
| Project memory | CLAUDE.md | GEMINI.md or AGENTS.md | AGENTS.md | .github/copilot-instructions.md or AGENTS.md |
| Session resume | claude --continue or /resume | agy --continue or /resume | codex resume --last or /resume | copilot --continue, --resume, or /resume |
| Git state | Reads status/diff/log | Similar | Similar | Similar |
| Plan files | Saved by the tool (check /help) | Conversation artifacts | N/A | Not verified |
| Auto-memory | On by default; toggle in /memory | None by design; /learn proposes a rule you review | /memories (a recall layer; keep rules in AGENTS.md) | /memory (--enable-memory) |
Best practices:
- One task, one session. Build, commit, clear, move on. The single most impactful habit.
- Commit before you clear. Git is your permanent save. Conversation is temporary.
- Use plan mode for complex work. Natural breakpoints for clearing between phases.
- Save state before clearing. Ask the AI to summarize progress, then add it to your project memory file.
- Use
/btwfor throwaway questions (Claude Code, Codex, and Antigravity; not verified in Copilot). It sees the conversation but stays out of its history. - 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 codeYour 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:
| Problem | Recovery |
|---|---|
| AI changed files you didn’t want changed | git 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 commit | git reset --soft HEAD~1 (keeps changes staged for review) |
| Command is hanging | Press Esc to stop the current action (or Ctrl+C) |
| AI is going off-track | Type /clear and restate your goal in 1-2 sentences |
| Context is getting stale | At a natural boundary, /compact with a note of what to keep (Claude Code, Codex), or /clear and restate the goal |
| Not using Git yet | Restore 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.
Common workflows
Prototype flow:
mkdir prototype && cd prototype && git init- Start your AI tool as the tool modes table shows (with just its name if you want to be asked more often)
- Switch to plan mode, describe what you want, and read the plan before you tell it to build.
- Test the output. If it works,
git add . && git commit -m "working prototype".
High-risk task flow:
- Activate plan mode (
/planorShift+Tab) - Review the AI’s proposed plan
- Approve step by step, checking diffs along the way
- Test thoroughly before committing
Long session rescue flow:
- Run
/compactwith a note of what to keep (Claude Code and Codex; elsewhere check/help) - If quality is still poor, try
/modelto switch models - If context is completely lost,
/clearand 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.
/clearbetween unrelated tasks,/compactwith 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;
/rewindcovers only what each tool recorded, and Codex has none. - Review before you commit.
/code-reviewin Claude Code,/reviewin Codex and Copilot,/diffplus 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.