# What taste-1 actually is — reading the command-code 1.58.0 npm bundle

> Source: <https://gist.github.com/safzanpirani/5bd7a77ce304edb16f768982bb26bcc0>
> Published: 2026-09-19 10:16:03+00:00

Full teardown, including every system prompt, the three sources taste feeds on, the tool
catalogue, the wire protocol and the telemetry:
[https://gist.github.com/safzanpirani/26170636512c0b50494d6a70acfece8d](https://gist.github.com/safzanpirani/26170636512c0b50494d6a70acfece8d)

Web version: [https://cmd.safzan.dev](https://cmd.safzan.dev)

Notes from reading the `command-code` npm package (Command Code CLI), **version 1.58.0**,
2026-09-19. Everything below is from the shipped bundle; line numbers are for `dist/cli.mjs`
run through `npx prettier --parser babel` (115,067 lines).

Reproduce with:

```
npm i -g command-code@1.58.0
npx prettier --parser babel \
  "$(npm root -g)/command-code/dist/cli.mjs" > cli.pretty.mjs
```

No unpacking needed — it is a plain minified ESM bundle, and esbuild's `--keep-names` is on, so
every function is wrapped in `__name(fn, "originalName")` and the original identifiers survive.

From [https://commandcode.ai/docs/taste](https://commandcode.ai/docs/taste), and repeated verbatim in the CLI's own help text
(`:64741`) and FAQ (`:9371`).

Archived copies, in case the page changes — the claim is present in every Wayback snapshot of this page from 2025-12-09 onward, so it is a long-standing position rather than a recent edit:

- [2026-09-07](https://web.archive.org/web/20260907191124/https://commandcode.ai/docs/taste) (most recent capture)
- [2026-03-13](https://web.archive.org/web/20260313174739/https://commandcode.ai/docs/taste)
- [2025-12-09](https://web.archive.org/web/20251209084020/https://commandcode.ai/docs/taste) (earliest capture)

The text:

"Taste is powered by our meta neuro-symbolic AI model **taste-1** with continuous reinforcement
learning (RL). We combine reasoning with neural intuition to create an invisible architecture
of your choices, structures, patterns and tooling preferences."

The docs page bullets:

- "**Continuously learning** side learns the texture of your code (explicit & implicit feedback)."
- "**Meta Neuro-Symbolic AI model taste-1** enforces the invisible logic of your choices."
- "**Reflective Context Engineering** of a self-aware RL feedback loop to build skills."

It also embeds an architecture diagram at `/docs/mns.png` whose alt text is
`meta neuro-symbolic ai model taste-1`.

`runTasteLearningAgent` (`:55352`) and `compileTasteContext` (`:55686`):

1. 
**Shell out to git.**`collectCommits` +`getSubstitutions` run`git show --format= -U3 --diff-algorithm=histogram -b --ignore-blank-lines -M <hash>` over up to 200 commits and extract before→after line pairs.
2. 
**Build a prompt.**`compileTasteContext` concatenates those hunks into a markdown document
headed`# Dynamic Taste Analysis — Code Change Patterns` and`## Correction Diffs — What Wrong→Right Looks Like` , ending with:`## Instructions for Taste Learning`` You are analyzing code change patterns from a real repository. Based on the correction diffs above, generate deeply personal and opinionated coding taste.`followed by eight numbered style guidelines ("Be specific, not generic," "Extract the WHY from patterns," "Capture anti-patterns too"…).
3. 
**Send it to an ordinary model.** That string becomes a single`role:"user"` message on a
normal session, posted to the same`/alpha/generate` endpoint every other request uses, on
whatever model is currently selected:

``` js
const o = await e.createSession({ sessionId: …, baseUrl: t.getApiBaseUrl() });
o.setState({ state: { …, messages: [
  { role: "user", content: [{ type: "text", text: e.compiledContext }] } ] } });
await o.learn({ outputDir: e.outputDir });
```

4. 
**The model writes markdown.** Output lands in`.commandcode/taste/taste.md` .
5. 
**The file is pasted back into the system prompt** on every later turn
(`renderTasteSection2` ,`:35886` ):

```
<taste>
Below is the complete content of the .commandcode/taste/taste.md file.
…
</taste>
```

git diffs → a prompt → an ordinary model → a markdown file → prompt prepending.

No embeddings. No weight updates. No RL loop. No symbolic component. No distinct model.
It is the `CLAUDE.md` / `AGENTS.md` pattern with an automated first draft.

Exactly one place — the TUI status bar (`:97801`):

```
y = Boolean(o && byokProviderId({ model: o })) ? "" : " · taste-1",
```

A literal string appended whenever you are **not** on BYOK. Configure your own provider and the
badge disappears while the feature behaves identically. It labels whichever model you picked
(`claude-sonnet-4-6`, `moonshotai/Kimi-K2.5`, …). It never names one.

Grep the bundle for `taste-1` and you get four hits: this line, the FAQ string, the help string,
and the billing string below. There is no model id, no routing entry, no catalog record.

From the plans help text (`:64749`):

"Premium requests: Any request that uses a premium model (like taste-1) during your coding session."

Classifying `taste-1` as a premium model is what justifies charging premium-request rates for
taste operations. The model catalog in the same bundle lists ~80 real model ids
(DeepSeek, Kimi, GLM, MiniMax, Qwen, GPT, Claude, Grok, Gemini) with `contextWindow`,
`reasoningEfforts` and provider routing. `taste-1` is not among them.

The CLI states (`:64741`, `:64749`):

"Privacy: Taste processing runs on your codebase and stores learning data locally only."

"Taste processing runs on your codebase and stores learning data in your project and on your local machine only."

Storage is local — `taste.md` is written under `.commandcode/taste/`. Processing is not.
Step 3 above posts `compiledContext` to `https://api.commandcode.ai`, and that context embeds
**verbatim source lines**. `buildSnippet2` (`:55612`) emits changed lines prefixed `→` with
surrounding context lines indented two spaces:

```
Snippet:
  <context line>
→ <your changed line>
  <context line>
```

Sending code to a model is what an inference call is, and is unremarkable in the main agent loop where the user knows it is happening. Taste is presented as local analysis. "Runs on your codebase … on your local machine only" reads as a claim that the code does not leave the machine, and it does.

The bundle ships a sensitive-filename denylist (`:68900`):

```
.env  .env.*  *.pem  *.key  id_rsa  id_rsa.*  id_ed25519  id_ed25519.*
id_ecdsa  id_ecdsa.*  credentials  credentials.*  *.crt  .npmrc  .pypirc  .netrc
```

`hasSensitiveBasename` consumes it at six call sites — write-guarding (`:17640`), path-safety
sets (`:17728`, `:17773`), IDE/telemetry file lists (`:74588`, `:74600`, `:74606`).

The taste extractor is not one of them. Its only filter is `isNoiseFile` (`:55556`, list at
`:77172`):

```
package-lock.json  pnpm-lock.yaml  yarn.lock  CHANGELOG.*  .versionbot/
*.min.js  *.min.css  dist/  *.map
```

That is a relevance filter, not a safety filter.

Because taste reads **history** rather than the working tree, a repo that ever committed a
`.env`, `*.pem`, `id_rsa` or `credentials` file will have those hunks extracted verbatim and
uploaded with everything else — deleting the secret from HEAD does not remove it from the
commit range taste mines.

The filter exists and is applied in six places. It is missing from the one path that ships historical file contents off the machine.

- Opt out of telemetry with `DO_NOT_TRACK=1` or`"telemetry": false` in`~/.commandcode/config.json` .
- The taste **feature** is genuinely useful. An automated first pass at a conventions file,
derived from what you actually did rather than what you'd claim you do, beats a blank`CLAUDE.md` . None of the above is an argument against using it.
- The objection is narrow: the mechanism is prompt engineering, and it is described as a neuro-symbolic model with reinforcement learning.
- All of this is from a published npm package, read as shipped. Version-pinned to 1.58.0; later releases may differ.