Command Code: a terminal coding agent that keeps a taste profile of your edits

The correction loop Command Code is trying to close

Most coding agents treat a rejected suggestion as noise. You accept one completion, delete the next, rewrite the third, and the tool starts the following session with no memory of any of it. Command Code's README frames this as the correction-loop problem and sells the fix as a taste profile: every accept, reject and edit is described as a signal that shapes that profile. The stated target user is someone running an agent against open models (the repository topics list anthropic, openai, deepseek, glm and kimi) from a command line, who keeps correcting the same stylistic choices session after session. The README's own claim is that rules decay while taste compounds, which is a positioning statement rather than a mechanism, and nothing in the repository explains how a signal becomes a stored preference. Treat the framing as a hypothesis you can test in one session, not as a guarantee.

How taste-1 and the session loop fit together

Command Code ships as a CLI, so the architecture visible from the README is a local process that talks to a model and keeps state between runs. The README names taste-1 as the model at the centre of the taste architecture and describes it as enforcing the invisible logic of your choices, but it does not say whether taste-1 is a separate model, a layer over the model you select, or a ranking step applied to candidate edits. What the README does document is the interaction surface: interactive mode gives you slash commands, Bash mode entered with !, and file path autocomplete with @. Those three input modes are the points at which your behaviour is observable, which is the plausible source of the signals the profile is built from. The repository itself is sparse. Top-level entries are .github/ and readme.md, so there is no source tree to read for the storage format, no schema for the profile, and no explanation of whether it lives on disk, in a hosted account, or both. The docs site is where that would have to be answered, and the README only links to it.

Installing Command Code and running a first session

The README gives a two-step quickstart. The package is published on npm as command-code and installs globally, which means you need a working Node and npm on the machine and permission to write global packages. If your environment blocks global installs, that is the first thing you will hit, and the README does not offer an alternative install path.

npm i -g command-code

After the install completes, the binary you invoke is cmd. Change into the project you want the agent to work in and start it there, because the README's example runs it from inside the project directory rather than pointing it at a path.

cd your-project
cmd

The README states that typing / opens the command menu, ! switches to Bash mode, and @ triggers file path autocomplete. Those are the documented entry points for a session; the quickstart page at commandcode.ai/docs/quickstart is where the README sends you for the full onboarding flow. For sharing a profile with a team, the README gives npx taste push and npx taste pull as the portable commands, without documenting what is transferred or where it is stored. If you want the flags and subcommands behind cmd, the README points to a CLI reference page rather than listing them.

What the repository does not tell you

The licence field is empty and the repository has no LICENSE file among its top-level entries, only .github/ and readme.md. For a tool that ingests your edits and can push a derived profile to a remote location, that is a real gap: you cannot read the terms that govern the package you are installing globally. The README also does not document rollback, so if a taste profile starts pulling your suggestions in a direction you dislike, there is no stated way to reset it, inspect it, or discard a single bad signal. There is no release history and no changelog, so upgrade cost is unquantifiable from the repository alone: you cannot tell whether a routine npm update will change how the profile is stored or invalidate it. Finally, the README describes taste as continuously learning but gives no retention policy, no statement about whether signals leave your machine, and no description of what npx taste push transmits. None of this makes the tool wrong; it makes the trust decision premature for anyone who has to answer to a security review.

Where Command Code is the wrong tool

Command Code assumes an interactive terminal session. If your work runs in CI, in a headless container, or as a scripted step with no human accepting or rejecting edits, the learning loop has nothing to learn from: the signals it depends on are human decisions, and an unattended pipeline produces none of them. The same applies if your team standardises on an editor-integrated assistant, since a profile built from terminal sessions does not follow you into that editor. It is also a poor fit when your constraint is auditability rather than capability. A tool whose value proposition is a personal, portable, continuously updated profile of your coding decisions is in tension with a requirement that every automated change be traceable to a written rule; the README's own line that rules decay is an argument against rule-based review, and you may not be able to make that argument to your reviewers. If your project depends on a specific model that the repository topics do not list, there is no statement in the README about which providers are supported beyond that topic list.

Command Code compared with opencode

Searches around Command Code frequently pair it with opencode, and the difference in approach is worth stating plainly. opencode is a terminal coding agent in the same category, and the comparison that matters is not which one writes better code but where the state lives. Command Code's distinguishing mechanism is a taste profile that accumulates from your accept, reject and edit decisions and is explicitly designed to travel through npx taste push and npx taste pull. That makes the unit of value a portable artefact about you, not a configuration file about the project. A tool that keeps its behaviour in project-level configuration gives you something you can review in a pull request and hand to a new teammate as text; Command Code gives you something you push and pull. If your team's review culture runs on diffs, the second model is harder to fit into it. If your frustration is that you keep re-explaining your preferences, the first model is the one that never fixes it. Choose based on which of those two problems you actually have.

Adoption checklist before you install

Verify the licence first, because the repository does not state one. Verify what npx taste push sends and where it lands, because the README documents the command and nothing else about it. Verify the supported model list against the models you actually use, since the repository topics are the only signal available and topics are not documentation. Verify that a global npm install is acceptable in your environment, and read commandcode.ai/docs/reference/cli for the flags the README omits. On upgrades, the absence of releases and a changelog in the repository means you should treat each npm update as unverified until you have re-run a session and confirmed the profile still behaves. The last push to the repository was on 2026-08-15, so the README you are reading reflects that state and not anything after it.

Editorial conclusion

Adopt Command Code if you already drive a coding agent from a terminal, use open models such as DeepSeek, GLM or Kimi, and want a profile of your edit decisions that can be pushed to teammates with npx taste push/pull. Skip it if you need an auditable licence file, a documented data-retention policy for the taste profile, or a published CLI flag reference before you commit. Before installing, check whether your Node toolchain can run a global npm package, read commandcode.ai/docs/reference/cli for the flags the README never lists, and confirm what taste push sends and where it lands.

Frequently asked questions

Official sources

1. CommandCodeAI/command-code on GitHub
2. Issues
3. Project website
4. README