Command Code, the terminal agent that learns your taste.

It ships, fixes, tests and refactors with the patterns you keep, and forgets the ones you delete.

Command Code is a CLI agent that runs where you already work: the terminal. It has the full tool stack you would expect (file operations, shell, grep and glob, web search, todo tracking, extended thinking, and a deep multi-dimensional PR review), and it drives any frontier model you point it at, from Anthropic, OpenAI, Google, xAI, DeepSeek, Qwen, and more. The differentiator is taste: it treats every accept, reject and edit as a signal, distils those into project-level skills and a personal memory, and opens the next session already knowing the conventions you prefer. Your code, skills and memory stay on your machine, and it never trains on your work.

your-project/
├─ .commandcode/
│  ├─ taste/taste.md      # learned style, with confidence scores
│  ├─ skills/             # reusable /commands your team shares
│  └─ memory/             # facts that persist across sessions
└─ src/ ...               # your actual code, unchanged and local

Why it mattersThe agent meets you in the terminal, not a side panel. Nothing leaves your machine, so you get personalization without shipping your codebase to a training set.

Not fine-tuning. A live loop that turns your reactions into constraints the model must follow.

A plain model does output = LLM(prompt). Command Code conditions on you: output = LLM(prompt | taste(you)). It runs a continuous loop with no batch training step. The model generates code under your current taste constraints; you accept, reject or edit; a symbolic layer extracts what changed into explicit, readable rules; those rules update your taste profile; the next generation uses them. The constraints are stored transparently in .commandcode/taste/taste.md with confidence scores, so you can read and edit what it learned. Over time the correction count drops as the profile compounds.

Why it mattersThe learning is interpretable and editable, not a black-box weight update. You can open taste.md, read a rule, and delete it if you have changed your mind.

Three memory layers do three different jobs; only one of them is yours alone.

It is easy to conflate the pieces, so pull them apart. Skills are reusable know-how ("how to scaffold a REST endpoint"), shared with your team, and two engineers using the same skill get the same output. Memory holds durable facts about the project (the ports, the deploy target, the gotchas). Taste is the personal layer: the style constraints learned from your reactions, distinct for every engineer even on the same skill. Skills give the agent knowledge; taste gives it your experience, and in the long run alignment with how you actually work is what wins.

Why it mattersYou share skills and memory; you keep taste. That split is what lets a team stay consistent on conventions while each engineer keeps their own hand.

Run it in a project, trust the folder, give it a real task, then read what it picked up.

Change into a project and launch the agent. On the first run it asks you to trust the folder (skip the prompt with cmd --trust). Give it a concrete task with your preferred tools baked in, so the very first accept becomes a taste signal. After it finishes, press Ctrl + T to open the learned preferences in .commandcode/taste/taste.md. If you have older projects, import their patterns with /learn-taste (or cmd --learn-taste) so the profile starts warm instead of empty.

cd your-project
cmd                     # launch; trust the folder when asked

# then, in the interactive prompt, be specific about tools:
> Build a date.js CLI that prints the ISO format of a date.
  Use commander.js and pnpm.

# after it runs, inspect what it learned:
# press Ctrl + T  ->  opens .commandcode/taste/taste.md

# warm-start taste from your existing repos:
/learn-taste

Why it mattersThe first session is where you teach it your defaults. Naming the tools you want ("commander.js and pnpm") turns your acceptance into a durable rule instead of a one-off.

A conversation for daily work, a one-shot for pipelines, and a think-first mode for big changes.

Interactive is the default: a chat where you ask, it edits files and runs commands, and you steer. Headless is one query in, one answer out, driven by -p (and --yolo to auto-approve), which is what you wire into CI, scripts, and git hooks; it accepts piped stdin. Plan mode makes it reason through architecture and multi-step refactors before it touches a file. Any model you have configured (Claude Opus 4.8, Sonnet 5, GPT-5.5, DeepSeek, and more) works across all three.

# interactive (default) - a steerable conversation
cmd

# headless - one shot, ideal for CI and scripts
cmd -p "review the staged diff and flag any missing tests"

# headless, auto-approve every tool call
cmd -p "bump the minor version and update the changelog" --yolo

# pipe context in from another command
git diff | cmd -p "write a conventional-commit message for this diff"

Why it mattersHeadless mode is how taste reaches your pipeline. The same learned style that guides your interactive edits also shapes the code an automated job writes.

Launch from the integrated terminal and the agent sees the file you are looking at, and your selection.

The fastest path: open VS Code, open its integrated terminal, and run cmd there. The companion extension installs itself on first run, and the agent picks up your open file and highlighted lines as context. If it does not connect, run /ide inside a session to check status, install the extension, and see diagnostics, or run cmd --ide-setup for a non-interactive install in scripts. This also works with Cursor and Windsurf. Watch three signals: an IDE ✓ flash when connected (or run /ide in yellow when not), the current file shown as In auth.ts at the bottom of the input, and a hint like Selected 23 lines from auth.ts confirming shared context.

# easiest: run this INSIDE the VS Code integrated terminal
cmd                # extension auto-installs on first run

# check / repair the connection from a session
/ide               # status, install, diagnostics

# non-interactive install (for setup scripts)
cmd --ide-setup

Why it mattersShared context removes the paste step. "Fix this" means the file and lines you have open, so the agent stops guessing which code you meant.

PowerShell blocks script files by default, so the npm-installed launcher will not run until you allow it.

Global npm binaries on Windows are .ps1 script shims, and PowerShell ships with script execution locked down. The moment you run the CLI you get: cmdc.ps1 cannot be loaded because running scripts is disabled on this system. The fix is to set the execution policy to RemoteSigned for your user only, which lets scripts you created locally run while still requiring downloaded scripts to be signed. You do not need admin rights for the CurrentUser scope. Verify with Get-ExecutionPolicy, then reopen the terminal.

# the error you will see:
# cmdc.ps1 cannot be loaded because running scripts is
# disabled on this system.

# fix: allow local scripts for your user (no admin needed)
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

# confirm it took
Get-ExecutionPolicy -Scope CurrentUser      # -> RemoteSigned

# need a one-time exception without changing your setting?
Set-ExecutionPolicy -Scope Process -ExecutionPolicy RemoteSigned

Why it mattersRemoteSigned is the safe middle ground. It unblocks your own tooling without flinging the door open to unsigned scripts off the internet, which is what Unrestricted would do.

No Node.js means no npm, and no npm means the install command itself fails. Fix the root, not the symptom.

If npm i -g command-code fails with 'npm' is not recognized as an internal or external command, or the agent later reports node not found, the runtime is either not installed or not on your PATH. npm ships inside Node.js, so you install one thing. Grab the current LTS from the official site or via winget, then close and reopen the terminal so it reloads PATH (skipping this reopen is the reason "I installed Node but it still says not found"). Verify both binaries, then retry the install.

# install Node LTS (npm comes with it):
#   - download from https://nodejs.org  (LTS), or:
winget install OpenJS.NodeJS.LTS

# CLOSE and REOPEN the terminal so PATH refreshes, then verify:
node -v          # v22.x
npm -v           # 10.x

# now the install works:
npm i -g command-code@latest

# if npm installs but 'cmd' is still not found, check the global bin:
npm config get prefix    # that folder must be on your PATH

Why it mattersAlmost every "Command Code won't install" report is really a Node or PATH problem. Fix the runtime once and the CLI, npm, and every other Node tool all start working together.

One pass to prove the setup end to end, then push your learned skills so the team pulls them in.

Once Node, npm and the CLI all answer, run a single verification pass: version, login, a trivial headless prompt. When that works, the payoff of taste is sharing: project-level skills your profile generated can be pushed to a registry and pulled by teammates, so the whole team codes against the same conventions while each person keeps their personal taste layer. On Windows remember the binary is cmdc (or plain cmd inside WSL); everything else matches macOS and Linux.

# prove the whole chain (use cmdc on native Windows)
node -v && npm -v && cmd --version
cmd login
cmd -p "print a one-line hello and exit"     # headless smoke test

# share the skills your taste generated
npx taste push        # publish to your team registry
npx taste pull        # a teammate pulls them in

Why it mattersA green smoke test plus a pushed skill set is a working team install. Taste stays personal; skills become the shared, versioned conventions everyone starts from.