Command Code: a CLI coding agent that builds a taste profile from your edits
Command Code AI — the best coding agent for open models.
At a glance
- What is it?
- Command Code is an npm-installed terminal agent for open models that records every accept, reject and edit as training signal for a model it calls taste-1. The mechanism is documented at a high level; the repository itself is a readme and a .github folder, so most operational detail lives on the vendor's docs site.
- Who is it for?
- Adopt Command Code if you already run an open model through a terminal agent and you want the accept/reject loop to feed something persistent rather than resetting each session. Do not adopt it if you need to audit the learning pipeline before it touches your codebase, or if you need a documented rollback path.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Yes. The repository last received commits 31 days ago.
- What is it written in?
- GitHub does not report a main language for this repository.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What Command Code actually solves for a terminal-first engineer
Most coding agents start every session from zero. You correct the same stylistic habit on Monday and again on Thursday, because the correction lives in a chat transcript that nobody reads twice. Command Code's pitch is that the correction should persist. The README describes it as "the coding agent that learns your coding taste" and says every accept, reject and edit becomes a signal that shapes a taste profile. That is the whole thesis: the agent keeps a model of how you write code, and that model is supposed to get sharper the more you use it.
The audience is narrow and specific. You work in a terminal, you run an agent against an open model rather than a closed hosted one, and you have opinions about code style that you are tired of restating. The topics list on the repository includes deepseek, glm, kimi and openai alongside anthropic, which tells you the intended model surface is broad. If you are happy with a browser-based assistant and you do not care whether your preferences survive the session, this is not aimed at you.
How the taste loop and the taste-1 model fit together
The README names a model called taste-1 and describes it as "the core of our taste architecture: it learns from you, thinks like you, and grows with you." It also uses the phrase "Meta Neuro-Symbolic AI" and says taste-1 "enforces the invisible logic of your choices and coding taste." That is the extent of the public mechanism in the repository. The README does not document how signals are collected, whether they leave your machine, what the profile is stored as, or how the symbolic half of the architecture constrains the neural half.
What the repository does show is the shape of the product. There is an interactive mode with slash commands, a Bash input mode triggered by !, and file path autocomplete triggered by @. There is a documented CLI reference page at commandcode.ai/docs/reference/cli for flags and subcommands. And there is a sharing mechanism, described in the README as "portable via npx taste push/pull," with the line "Rules decay. Taste compounds." That last part is the most consequential design decision in the whole project, and it is stated in six words. A taste profile that can be pushed and pulled is a shared artefact, which means it is also a thing that can drift between team members and a thing that can carry one person's habits into another person's sessions. The README does not address conflict resolution between two pulled profiles.
Installing Command Code from npm and running your first session
The README gives two commands for the basic path. The package is published to npm as command-code, and the global install is the supported route. Run this from any directory:
npm i -g command-codeAfter the install completes, the cmd binary should be on your PATH. Move into the project you want the agent to work on, then start it with no arguments:
cd your-project
cmdThe README does not state what the first screen looks like or whether an initial configuration step runs before the session opens. Once you are inside a session, the interactive mode documented in the README uses three input prefixes. Type / to open the command menu, use ! for Bash mode, and use @ for file path mention autocomplete:
/feedbackThe /feedback command is the one the README names explicitly as the way to report issues, alongside opening a GitHub issue. The README points to commandcode.ai/docs/quickstart for "the full onboarding flow," which suggests the two-command path above is deliberately minimal and that model selection, authentication or profile setup happens elsewhere. The CLI reference at commandcode.ai/docs/reference/cli is where flags and subcommands are listed; the repository README does not reproduce them.
The repository is a readme, and that is a real limitation
The top-level entries in this repository are .github/ and readme.md. There is no source tree, no package manifest, no test suite, no changelog and no release history retrieved. The primary language field is unknown and the licence field is unknown. For an engineer trying to decide whether to adopt a tool, that matters more than any feature list.
You cannot read the code that decides what a taste signal is. You cannot check whether the profile is written to disk in your project, to a home directory, or to a remote service. You cannot verify the claim that taste-1 "enforces the invisible logic of your choices" because the enforcement logic is not in the repository. The README links to commandcode.ai/docs/taste for the deeper explanation, so the honest position is that the learning pipeline is documented by the vendor and not by the artefact you are installing. That is a normal arrangement for a hosted product with a thin CLI wrapper, and it is a poor arrangement for anyone whose threat model includes "the agent that edits my code also decides what to remember about me."
The second limitation is the sharing mechanism. npx taste push/pull is described in one line with no documented conflict handling, no documented scope, and no documented rollback. If taste profiles can be pushed to a team and pulled by a teammate, then a bad profile is a shared bad profile. The README does not say how to discard one.
Command Code versus OpenCode: what changes in the approach
OpenCode is the comparison people search for, and the difference is not the terminal UI. Both are command-line coding agents that talk to models and edit files in your project. The divergence is what each one treats as the durable asset. An OpenCode-style agent keeps its configuration in files you own: you write the agent definitions, the model bindings and the instructions, and the behaviour is reproducible from that configuration. Command Code inverts this. The durable asset is a learned taste profile produced by taste-1 from your accept, reject and edit signals, and the README's framing is that this profile is the thing that compounds.
That inversion has consequences. Configuration is inspectable and diffable; a learned profile is neither, at least not from anything in this repository. Configuration is portable because you can read it; a profile is portable because there is a push and pull command, which is a different kind of portability. If your team's reason for standardising on an agent is that every engineer gets the same behaviour from the same config, the taste model works against that goal, because it is designed to make each engineer's sessions diverge toward their own habits. The README's own tagline, "Rules decay. Taste compounds," is an argument against the rules-as-configuration approach, and you should read it as a positioning statement rather than a neutral observation.
Maintenance, licence and upgrade cost
The repository is not archived, and the last push was on 2026-08-15. That is recent enough that the project is not dormant, but the repository contains only a readme and a .github directory, so a push here tells you the documentation or issue templates changed. It does not tell you the CLI changed. Version history for the npm package command-code is the thing to watch instead, and the README embeds an npm version badge, which means the published package is the release channel.
On licensing, the repository does not state a licence. The licence field is unknown, there is no LICENSE file among the top-level entries, and the README does not mention one. That is a gap you have to close before you put this in a commercial pipeline, because an unlicensed package is not the same as a permissively licensed one. Nothing in the README describes what happens to a taste profile when you stop paying, stop using the tool, or leave a team, and nothing describes whether the profile is deletable. Treat the upgrade cost as two separate questions: the npm package version, which you can pin, and the taste-1 model behind it, which the README presents as a vendor-hosted component with no versioning story.
Who should run cmd today and who should wait
Run it if the correction loop is your actual pain. If you spend the first ten minutes of every agent session re-explaining your conventions, and you are willing to accept that the mechanism doing the learning is documented on a website rather than in the code you installed, Command Code is built directly at that problem. The install is two commands and the interactive prefixes are documented.
Wait if you need to inspect the pipeline, if your organisation requires a stated licence before adoption, or if you work on a team where a shared and drifting profile would be worse than no profile at all. Wait also if you need a documented way to roll back a pushed taste profile, because the README does not describe one.
The first thing to verify is not a feature. Open commandcode.ai/docs/taste and read what the taste-1 model actually stores and where, then decide whether that is a trade you want to make. The second thing to verify is the npm package itself, since command-code is a generic enough name that you should confirm you are installing the publisher you intend.
Editorial conclusion
Adopt Command Code if you already run an open model through a terminal agent and you want the accept/reject loop to feed something persistent rather than resetting each session. Do not adopt it if you need to audit the learning pipeline before it touches your codebase, or if you need a documented rollback path. Before installing, verify three things: that the npm package command-code is the one you intend to run, that the taste-1 behaviour described at commandcode.ai/docs/taste matches what you expect from a shared profile, and that npx taste push does not send more than you are willing to share with a team.
Frequently asked questions
What is Command Code AI?
It is a terminal coding agent distributed as the npm package command-code. The README describes it as a coding agent that builds software and continuously learns your coding taste, with a model called taste-1 at the centre of that learning.
How do I install Command Code?
The README gives a single global install command, npm i -g command-code. After that you change into your project directory and start the agent by running cmd.
How do I use Command Code once it is running?
The README documents an interactive mode with three input prefixes: / opens the command menu, ! switches to Bash mode, and @ triggers file path mention autocomplete. The /feedback command is named as the way to report issues.
Which models does Command Code work with?
The repository topics list ai, anthropic, openai, deepseek, glm and kimi, which indicates the intended model surface spans open and hosted models. The README itself does not document per-model configuration, and points to commandcode.ai/docs/reference/cli for flags and subcommands.
How is Command Code different from OpenCode?
Both are command-line coding agents that edit files in your project. Command Code's distinguishing claim is that it accumulates a learned taste profile from your accept, reject and edit signals, shareable through npx taste push/pull, whereas a configuration-driven agent keeps its behaviour in files you write and can read.
Is Command Code open source?
The repository at CommandCodeAI/command-code contains only a readme and a .github directory, and no licence is stated in the README. The npm package is public, but that is not the same as an open source licence.
Community notes