Common workflows

Step-by-step recipes for everyday tasks. Each workflow shows a concrete scenario, the prompts to use, and what to expect.

Understand a new codebase

Start Command Code in the project root and ask for a high-level overview, then drill into specifics.

Get a broad overview

Ask for overview

> give me a brief overview of this codebase — structure, key packages, and entry points

Explore the architecture

Architecture

> explain the architecture patterns used here and how the modules connect

Zoom into a specific area

Dive deeper

> how is the payment system implemented? walk me through the flow from checkout to confirmation

Tip

Press ctrl+t to watch taste learning in real time as Command Code explores the project.

Reference files and directories

Use @ to include files or directories in any prompt. This gives Command Code the exact context it needs.

Reference a single file

Reference file

> explain the validation logic in @src/lib/auth.ts

This helps Command Code focus on the right file and provide targeted suggestions.

Reference a directory

Reference directory

> look at @src/app/api and explain the route structure

Command Code reads the directory listing and explains how the files relate.

Use the IDE extension for instant context

If you're using an IDE like Visual Studio Code or Cursor, install the Command Code extension with /ide or cmd --ide-setup. Once installed, selecting lines of code or clicking a file in your editor automatically injects that context into your prompt. No need to reference file paths manually with @.

Tip

@ triggers autocomplete for files and directories — start typing and press tab to select.

Find and fix bugs

Share an error, let Command Code trace the root cause, and apply the fix.

Share the error

Report error

> I'm seeing a TypeError when I run `pnpm dev` — "Cannot read properties of undefined (reading 'map')"

Find the root cause

Trace bug

> find where this error originates and explain why it happens

Apply the fix and verify

Fix bug

> fix the bug in @src/components/UserList.tsx and run `pnpm dev` to verify

Tip

Paste the full stack trace into the prompt — Command Code uses it to pinpoint the exact file and line causing the error.

Refactor code

Modernize a module while keeping behavior identical.

Identify what to refactor

Refactor target

> refactor @src/api/client.ts from callbacks to async/await — keep the same public API

Review and apply changes

Command Code shows a diff. Approve the edits or ask for adjustments before they're written.

Run tests to confirm

Verify

> run the tests for the API client to make sure nothing broke

Safety net

Press Esc twice to open the checkpoint selector and rewind if the refactor went wrong.

Write tests

Add tests for a module using the testing framework your project already uses.

Generate tests

Add tests

> add tests for @src/lib/auth.ts using Vitest — cover the happy path, invalid tokens, and expired sessions

Run and iterate

Run tests

> run the tests and fix any failures

Add edge cases

Edge cases

> add edge case tests for concurrent session limits and malformed JWTs

Tip

Ask Command Code to run tests after writing them — it catches failures and iterates until the suite passes.

Create a pull request

Review changes, generate a PR, and polish the description — all without leaving the terminal.

Review your changes

Summarize

> summarize the changes I've made to the auth module and check for anything I missed

Create the PR

Create PR

> create a pull request for these changes with a clear description and test plan

Command Code generates the title, description, and test plan using your commit history and diff.

Polish the description

Improve PR

> add a section about migration steps and link to the relevant RFC

Tip

Command Code requires the GitHub CLI (gh) to create PRs. Install and authenticate it first.

Fix a UI bug from a screenshot

Paste a screenshot of the broken UI directly into the terminal and let Command Code identify and fix the issue.

Share the screenshot

Copy a screenshot to your clipboard and paste it into the terminal, or reference an image file:

Reference image

> the modal is broken — here's what QA reported @screenshots/broken-modal.png

Identify the issue

Command Code analyzes the image, identifies the visual bug (overlapping elements, wrong spacing, missing styles), and locates the responsible component.

Apply the fix

Fix UI

> fix the z-index and padding issues in @src/components/Modal.tsx

Tip

Reference images with @path/to/screenshot.png — Command Code reads them like any other file.

Resume previous conversations

Pick up where you left off with --continue (most recent) or --resume (conversation picker).

Continue the most recent conversation

Continue

cmd --continue

This resumes your last conversation immediately.

Browse and select a past conversation

Resume picker

cmd --resume

This displays an interactive picker:

          Modified       # Messages   Git Branch            Summary

 ❯ 1.     20 hours ago   172          main                  Follow this practice and up...
   2.     21 hours ago   13           main                  Add the common workflows he...
   3.     22 hours ago   2            main                  does this {src/components/u...
   4.     22 hours ago   82           main                  pnpm dlx shadcn@latest add ...
   5.     1 day ago      2            ankit/features        all tools support  you have
   6.     2 days ago     20           ankit/commands        Update the content in each ...

Use arrow keys to navigate, Enter to select, Esc to exit.

Taste

Your taste profile carries between sessions — Command Code remembers your preferences even in new conversations.

Plan before you build

Use plan mode to explore the codebase and design an approach before any files change.

Enter plan mode

Start plan mode

cmd --plan

Or press shift+tab inside an active session to cycle into plan mode.

Describe what you want to build

Plan prompt

> design a role-based access control system for the API — explore the current auth setup first

Command Code reads files and proposes an implementation plan without making changes.

Review the plan and execute

Review the proposed steps. Approve to let Command Code implement them, or refine the plan first.

Read-only

Plan mode is read-only — Command Code explores but does not change files until you approve. See Plan mode.

Sync taste across machines

Push your taste profile to the cloud and pull it on another machine.

Push from your current machine

Push taste

cmd taste push

Pull on another machine

Pull taste

cmd taste pull

Verify your profiles

List taste

cmd taste list

This shows all taste profiles synced to your account. Manage your taste at Command Code Studio.

Equivalents

cmd taste and npx taste are equivalent. See Taste commands for the full list.

Review a pull request

Use the /review command to get an analysis of a PR without leaving the terminal.

Start the review

Review PR

/review 42

Command Code fetches the PR diff, analyzes the changes, and provides a structured review.

Read the analysis

The review covers code quality, potential bugs, missing tests, and style issues.

Fetch PR comments to address feedback

Fetch PR comments

/pr-comments

Retrieves all PR comments — issue comments and inline review comments — from the pull request associated with your current branch so you can address feedback directly in your session.

Leave comments

Comment on PR

> add a comment on the PR about the missing error handling in the webhook handler

Tip

Use /pr-comments on your feature branch to pull in all review feedback and address comments without leaving the terminal.

Create a shareable link to show teammates what you've tried.

Debug with Command Code

Work through the problem in a normal session — reproduce the bug, investigate, try fixes.

Share the session

/share

This copies a shareable link to your clipboard.

Stop sharing when done

Unshare

/unshare

Privacy

Local file paths are automatically removed from shared conversations.

Write complex prompts with an external editor

Press ctrl+g to open your $EDITOR for multi-line prompts with code examples.

Open your editor

Press ctrl+g in the input line. Your configured $EDITOR opens with a temporary file.

Write your prompt

Write a detailed, multi-paragraph prompt. Include code examples, constraints, or references. Save and close the editor.

Submit

The editor content becomes your prompt and is submitted automatically.

Setup

Set your editor: export EDITOR=vim or export EDITOR="code --wait". See Setting up your editor.

What's next

Taste — how taste learning works under the hood
Skills — specialized agent capabilities
Memory — customize behavior with AGENTS.md
Interactive mode — shortcuts, commands, and modes
CLI reference — all flags and subcommands

Questions or feedback? Join the Discord community.

Get Started