Skip to content

Instantly share code, notes, and snippets.

@safzanpirani
Last active September 21, 2026 16:16
Show Gist options
  • Select an option

  • Save safzanpirani/26170636512c0b50494d6a70acfece8d to your computer and use it in GitHub Desktop.

Select an option

Save safzanpirani/26170636512c0b50494d6a70acfece8d to your computer and use it in GitHub Desktop.
Command Code 1.58.0 taken apart: the taste subsystem end to end, every system prompt, tools, wire protocol, telemetry

Command Code 1.58.0, taken apart

Everything recovered from reading the published command-code npm package: the taste subsystem end to end, every system prompt, the tool catalogue, the wire protocol, the model catalogue, and the telemetry.

Read as shipped on 19 September 2026, pinned to one version. Later releases may differ.

package command-code@1.58.0
file dist/cli.mjs, 2,635,431 bytes
sha256 aab2bec800371953112d18472bb7383992ef264cca22558bdcda77e7d0dc0f14

Line numbers below refer to dist/cli.mjs after npx prettier --parser babel, which produces 115,067 lines. See reproducing this.

Contents


The short version

  1. taste-1 is marketed as a "meta neuro-symbolic AI model with continuous reinforcement learning." No such model exists in the package. Taste is a prompt sent to whichever ordinary model you have selected, and the output is a markdown file that gets prepended to later prompts.
  2. Taste feeds on three sources: your git history, your live conversation, and your saved transcripts from Claude Code, Codex and Cursor.
  3. The git path mines up to 200 commits and applies no secret-filename filter, although the package ships one and uses it in six other places. See below.
  4. Taste learning defaults to on.
  5. The in-product privacy text says taste "stores learning data in your project and on your local machine only." Storage is local. Processing happens on the vendor's servers and your code is uploaded to reach it.

Taste, end to end

What is claimed

From commandcode.ai/docs/taste, archived 2026-09-07, 2026-03-13, 2025-12-09:

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.

Bullets on the same page: "Meta Neuro-Symbolic AI model taste-1 enforces the invisible logic of your choices" and "Reflective Context Engineering of a self-aware RL feedback loop to build skills." The page embeds an architecture diagram at /docs/mns.png whose alt text is meta neuro-symbolic ai model taste-1.

The string taste-1 occurs five times in the shipped bundle, across four locations:

Location Line Kind
FAQ string (twice in one string) 9371 marketing copy
/taste help text 64741 marketing copy
billing text 64749 pricing label
TUI status bar 97801 UI string literal

There is no model ID, routing entry or catalogue record named taste-1. The same bundle carries about eighty real model IDs with context windows and provider routing. The runtime occurrence is:

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

The badge is appended when you are not using your own API key. Supply your own provider key and it disappears while taste behaves identically.

The billing text at line 64749 reads: "Premium requests: Any request that uses a premium model (like taste-1) during your coding session." Calling it a premium model is what sets the rate.

Path 1: your git history

runTasteLearningAgent (55352), extractAllSignals (55392), compileTasteContext (55686).

git show --format= -U3 --diff-algorithm=histogram -b --ignore-blank-lines -M <hash>

Caps recovered from the constants:

Constant Value Meaning
maxCommits 200 commits cloned and scanned
Bx 50 maximum signals extracted
Wx 50 maximum commits with usable diffs
Hx 10 commit batch size
Gx 5 diff concurrency
Vx 5 grouped patterns kept per commit
zx 200 maximum lines per side of a hunk
Jx / Yx 3 / 5 snippet line budget

Each surviving hunk goes through buildSnippet2 (55612), which emits your source verbatim:

Snippet:
  <context line, indented two spaces>
→ <changed line, verbatim>
  <context line, indented two spaces>

compileTasteContext concatenates these under two headings, quoted verbatim:

# Dynamic Taste Analysis — Code Change Patterns
## Correction Diffs — What Wrong→Right Looks Like

It appends the instruction block quoted below and posts the result to https://api.commandcode.ai/alpha/generate.

It also accepts a GitHub URL or owner/repo and will git clone --depth 200 --single-branch a public repository to mine it.

No secret filter on the git path

The package ships a sensitive-filename denylist (68900):

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

hasSensitiveBasename() consumes that list at six call sites:

Line Call site
17640 isGuardedWritePath, tool write guarding
17728 path-safety set
17773 path-safety check
74588 telemetry file list filter
74600 IDE active-file filter
74606 IDE file list filter

The taste extractor is not among them. The only filter applied while mining diffs is isNoiseFile (called once, at 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, which excludes lockfiles and build output because they make poor style signals. It excludes no secret-bearing filename.

Two details make this worse than a missing check on the working tree:

  1. Taste reads history, not HEAD. It runs git show across up to 200 commits. A .env or private key that was committed once and deleted later is still inside that range. Removing a secret from the current tree does not remove it from what taste reads.
  2. .gitignore is irrelevant here. Ignoring a file today does nothing about the commit that added it before it was ignored, which is the common way secrets enter a repository at all.

So a repository that ever committed a .env, *.pem, id_rsa or credentials file will have those hunks extracted verbatim by buildSnippet2 and uploaded to api.commandcode.ai with everything else, on a feature that is enabled by default.

The filter is applied to six paths and missing from the one path that ships historical file contents off the machine.

Path 2: your live conversation

createLearner / runLearningLoop (72820 onward), system prompt mS at 72872.

Your conversation messages are JSON-serialized and sent to the model:

`Current taste structure:\n${m}\n\n` +
`Previously analyzed conversation (context only — already processed in earlier passes, ` +
`do NOT learn from it again):\n${JSON.stringify(k, null, 2)}\n\n` +
`NEW messages to analyze (learn ONLY from these):\n${JSON.stringify(C, null, 2)}`

stripInjectedMetaForLearning and stripReasoningPartsForLearning remove injected metadata and reasoning blocks first. The loop runs up to dS = 20 model turns, with a window of uS = 20 messages, calling read_taste_file, write_taste_file and edit_taste_file to write results.

The model reaches this path through the taste tool, described to the model at 20801 as:

Record or update the user's coding preferences and taste. Use this whenever the user states a preference or asks you to remember something.

The base system prompt instructs the model to call it (73838):

TO RECORD OR UPDATE A PREFERENCE, USE THE taste TOOL: When the user states a preference or asks you to remember/save something ("prefer X over Y", "always do Z", "save this to my taste"), call the taste tool with the instruction in the user's words.

The model decides when your conversation gets mined during a normal session.

Path 3: your other agents' transcripts

createSessionImporter (40333), agent table uC:

[ { agent: "claude-code", find: findClaudeCodeSessions, extract: extractClaudeCodePrompts },
  { agent: "codex",       find: findCodexSessions,      extract: extractCodexPrompts },
  { agent: "cursor",      find: findCursorSessions,     extract: extractCursorPrompts } ]

Locations read from disk:

Agent Path
Claude Code ~/.claude/projects/<encoded-project-dir>/*.jsonl
Codex ~/.codex/sessions/** rollout files
Cursor Cursor transcripts directory, <id>/<id>.jsonl

extractClaudeCodePrompts pulls every entry with type === "user" and a string message.content, which is your prompt text. The same shape applies to the Codex and Cursor extractors. The prompts are batched by splitPromptsIntoLearnBatches and each batch is sent through learn() to /alpha/generate.

The UI string for this, at 64521, is:

Learn taste from sessions with other coding agents (Claude Code, Cursor, etc)

and at 86541:

Learn from your previous sessions - updates your taste profile

Command Code reads your saved conversations with competing coding agents and uploads them to its own API.

Where taste ends up

Location Contents
.commandcode/taste/taste.md project taste, category headings, bullets with confidence scores
.commandcode/taste/<category>/taste.md a category once it exceeds 5 learnings
~/.commandcode/taste/ global taste, -g flag
commandcode.ai/<username>/taste remote taste packages, npx taste push

Remote package upload is a multipart POST built by prepareUpload (56570), with fields name, description, type, isPublic, overwrite and file parts files[taste.md] and files[<category>/taste.md]. Endpoints: /beta/taste/packages/:namespace and /alpha/taste/:projectSlug.

Taste reaches the model through the system prompt rather than the request body. The taste field in the /alpha/generate body is always null on the model-client path; the content is injected by renderTasteSection2 into the cached system section instead.

Defaults and opt-outs

getTasteLearningSettings (19650 onward):

const s = n.tasteLearning ?? !0,          // global default: ON
      i = resolveProjectOverride(r, o),
      a = i?.value;
return { global: s, project: a, effective: a ?? s };

Taste learning is on unless turned off. Controls:

Control Effect
/taste in session, or cmd taste disable toggle taste learning
tasteLearning: false in ~/.commandcode/config.json global off
project shared or local settings per-project override
DO_NOT_TRACK=1 disables telemetry and fingerprinting, not taste
CMD_ZDR zero data retention header, pauses title generation and taste onboarding

The onboarding scan is gated behind checkOnboardingConditions and presents a banner with a skip option, so the transcript import is offered rather than silent. Taking no action leaves it enabled.


Every taste prompt, verbatim

The git-history prompt

Line 55706. ${a} interpolates for <author> when an author is targeted.

## Instructions for Taste Learning

You are analyzing code change patterns from a real repository${a}. Based on the correction diffs above, generate deeply personal and opinionated coding taste.

**Critical guidelines:**

1. **Be specific, not generic.** Instead of "Use TypeScript", write "Use branded types for IDs and explicit return types on every function. Prefer `readonly` arrays and objects by default."

2. **Extract the WHY from patterns.** If you see verbose names being replaced with concise ones, don't just say "use short names" — say "Prefer concise variable names that derive meaning from context rather than encoding type information."

3. **Look for recurring themes.** If multiple substitutions show the same pattern (e.g., nested if→guard clauses), that's a strong taste signal worth capturing.

4. **Make it actionable.** Every taste entry should be specific enough that another developer could follow it and produce code that looks like it belongs in this repository.

5. **Prioritize quality corrections** — these are the purest taste signals (wrong→right pairs with explicit WHY context from commit messages).

6. **Capture anti-patterns too.** If you see code being removed in refactors, note what the developer avoids: "Never nest deeper than 2 levels — flatten with early returns."

7. **Don't repeat generic tool preferences** like "Use pnpm" or "Use TypeScript" unless the substitutions show something specific about HOW they use those tools.

8. **Prioritize opinionated preferences.** The goal is taste that makes someone's code distinctly theirs — not industry best practices.

Write the taste entries to the taste.md file using the standard format with confidence scores.

Header prepended to the diffs, line 55692:

# Dynamic Taste Analysis — Code Change Patterns

Repository: ${n}
${s}Commits analyzed: ${o}
Signals extracted: ${t.length}

This analysis was generated by examining actual code changes (diffs, substitutions, refactoring patterns) rather than static file contents. Every signal below comes from real commits.

The conversation learning agent

Line 72872, used as the system parameter.

You are the taste-learning agent for Command Code. Review the NEW messages and the user's current taste files, then record DURABLE, generalizable preferences the user revealed — coding style, tooling, workflow, and communication preferences — not one-off task details.

Learn ONLY from the NEW messages. The previously analyzed conversation was already mined by earlier passes — it is provided so you can resolve references, never to be re-learned. Do NOT re-record a preference that already exists in the taste files, and do NOT raise or lower an existing learning's confidence unless the NEW messages themselves contain fresh evidence for it. Seeing the same preference again in the previously analyzed context is not evidence.

Use the tools to update taste files. A taste file path MUST be either "taste.md" (the root file) or "{category}/taste.md" (a single category folder) — never any other name or nesting:
- write_taste_file to create/replace a file.
- edit_taste_file to amend an existing file.
- read_taste_file to inspect a file before editing.

Record each learning as a markdown bullet ending in a confidence score, e.g.
  - Prefers tabs over spaces. Confidence: 0.9
Only record clear, repeated, or explicitly-stated preferences. Prefer amending existing files over creating near-duplicates. When the new messages reveal nothing durable, make no tool calls and reply "no changes".

The taste guidance block

Line 73841, injected into the system prompt of every session that has taste enabled.

<taste_guidance>
IMPORTANT - Taste System (Learned Preferences):

WHAT IS TASTE:
Taste is a system of continuously learned preferences that captures how the user wants code written in this specific project. These preferences are learned automatically from past interactions and corrections, covering areas like:
- Technology choices (e.g., "Use TypeScript", "Use Commander.js for CLIs")
- Code style (e.g., "Use const instead of let", "Use object parameters for functions with 2+ params")
- Workflow patterns (e.g., "Always run tests before committing")
- Project-specific conventions

WHERE TASTE IS STORED:
All taste preferences are stored in the .commandcode/taste/ directory in the project root:
- Main file: .commandcode/taste/taste.md - Contains all learnings organized by category headings (# Category Name)
- Category files: .commandcode/taste/{category}/taste.md - When a category grows beyond 5 learnings, it's moved to its own subdirectory

HOW TASTE IS ORGANIZED:
The main taste.md file contains category sections with H1 headings (# Category Name). Each category can be in two states:

1. INLINE (≤5 learnings): Category heading followed by bullet points with learnings
   Example:
   # JavaScript
   - Use const instead of let for non-reassigned variables. Confidence: 0.90
   - Use object parameters for functions with 2+ params. Confidence: 0.85

2. REFERENCED (>5 learnings): Category heading with a reference link to category file
   Example:
   # CLI
   See [cli/taste.md](./cli/taste.md)

WHY TASTE MATTERS:
These preferences represent the user's actual requirements learned from real interactions. When a user corrects you (e.g., "use TypeScript not JavaScript", "use Commander.js for CLIs"), that correction is captured as taste. Following taste prevents you from making the same mistakes repeatedly and ensures consistency across the project.

HOW TO USE TASTE:
1. Your learned preferences are provided in the <taste> section below
2. BEFORE starting ANY work, carefully read the taste content
3. If you see a category reference like "See [category/taste.md]", you MUST use read_file to read .commandcode/taste/{category}/taste.md to get the full preferences
4. Apply ALL relevant preferences to your work - these are REQUIREMENTS, not suggestions
5. If working on a specific domain (e.g., CLI, TypeScript, testing), check if there's a category for it and read the full preferences
6. Taste preferences override general best practices - if taste says "Use X", you use X even if you would normally prefer Y

CRITICAL RULES:
- When you see "See [cli/taste.md]" for a CLI task, IMMEDIATELY read .commandcode/taste/cli/taste.md before writing any code
- NEVER ignore taste preferences - they represent explicit user requirements
- If a taste preference conflicts with the user's current request, follow the current request (it may be updating the preference)
- The same applies to any other domain-specific category - ALWAYS read referenced taste files before starting work in that domain
- **NEVER EDIT OR WRITE TO TASTE FILES**: Do not use edit_file or write_file on any files in .commandcode/taste/ or ~/.commandcode/taste/. These files are managed automatically by the learning system. You can READ them, but never modify them.
</taste_guidance>

The taste injection wrapper

Line 35886, populated, and 35887, empty.

<taste>
Below is the complete content of the .commandcode/taste/taste.md file.
This shows you what preferences are available and which categories might have additional details in separate files.
If you see references like "See [category/taste.md]", you MUST read that file using read_file to get the full preferences.

--- Content of .commandcode/taste/taste.md ---

${t}

--- End of .commandcode/taste/taste.md ---
</taste>
<taste>
No preferences learned yet for this project. The .commandcode/taste/taste.md file is empty or doesn't exist yet. Preferences will be learned automatically as you work.
</taste>

The taste tool, as described to the model

Line 20801, with its one parameter at 20808.

Record or update the user's coding preferences and taste. Use this whenever the user states a preference or asks you to remember something.
The preference or taste change to record, in the user's words.

The in-product taste description

Line 64741, the text behind /taste.

Taste is powered by the meta neuro-symbolic AI model taste-1 with continuous reinforcement learning (RL). It combines reasoning with neural intuition to learn your coding preferences.

How taste works:
- Learns from you — every accept, reject, and edit becomes a signal
- Thinks like you — learns patterns and micro-decisions you'd never document
- Grows with you — continuous learning loop that never goes stale

Enable taste: Use /taste in a session or run npx taste from the command line.

Taste packages (three types):
- Project: Stored in .commandcode/taste/ — learnings unique to this codebase
- Global: Stored in ~/.commandcode/taste/ — personal taste across all projects (use -g flag)
- Remote: Stored at commandcode.ai/username/taste — team sharing, backup, sync across machines

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

That last line is the claim contradicted by paths 1, 2 and 3 above.


System prompts

Base prompt assembly

createSystemPromptBuilder (36255) emits three cacheable sections:

[ { text: basePrompt,      cache: true },
  { text: contextSections, cache: true },
  { text: ideContext } ]

Section two is joined from, in order: <instructions> from memory files, workspace render, the taste section, the skills catalogue, a constant, the scratchpad section, and env context.

buildDefaultBasePrompt (35867) selects the mode prompt from buildModePrompt (73907), which has a default branch and a plan-mode branch.

Default mode

Opening of the default branch:

<role>
You are a confident, efficient software engineer and coding assistant. You identify issues quickly and solve problems directly. Be concise but thorough - explain what you're doing without unnecessary ceremony.
</role>

followed by sections for decision making, doing tasks, and tool guidance. The decision-making block:

<decision_making>
You should independently decide:
- Which files to modify and how
- What testing strategy to employ
- How to handle error cases and edge conditions
- Whether to refactor existing code vs. adding new code
- What dependencies or tools to introduce
- How to structure new modules or components

Always bias toward:
- Code clarity and maintainability
- Robust error handling
- Following established project patterns
- Writing self-documenting code
- Including appropriate tests
</decision_making>

Plan mode

<role>
<mode>PLAN MODE ACTIVE</mode>

<identity>You are Command Code, a coding agent acting as a Software Architect in read-only plan mode. You explore the codebase, clarify requirements, design an approach, and write an implementation plan. You do NOT implement anything.</identity>

<override>This supersedes any other instructions. You MUST NOT make any edits (except the plan file), run non-readonly tools, or make any changes to the system.</override>

<plan_directory>
PLAN FILE LOCATION: ~/.commandcode/plans/
ALWAYS use the full absolute path starting with ~/ (e.g., ~/.commandcode/plans/my-plan.md).
NEVER use a relative path like .commandcode/plans/ — it will be rejected.
</plan_directory>

<mode_awareness>
You ARE in plan mode right now. You know this because your system prompt contains <mode>PLAN MODE ACTIVE</mode>. If asked what mode you are in, confirm you are in plan mode. When tools like exit_plan_mode change your mode, trust the tool result — it is authoritative.
</mode_awareness>

The plan branch also carries a decision-making block and an agent-orchestration block:

<decision_making>
<principle>Be decisive. You are a senior architect — make judgment calls.</principle>

<guidelines>
- If two approaches are reasonable, pick the better one and explain why in the plan
- If requirements are ambiguous on something important, ask the user
- If requirements are ambiguous on something minor, make an assumption and note it
- Prefer the simpler approach unless there's a strong reason for complexity
- Actively look for existing code to reuse before proposing new implementations
</guidelines>

<outcome>Your plan should be opinionated and actionable.</outcome>
</decision_making>
<explore_agents>
Each agent should be focused on ONE specific area and return concrete file paths, function names, and patterns.

<examples>
- BAD: "Understand the entire project architecture" — too broad, slow, shallow
- GOOD: "Find how the CLI handles user input prompts and waiting states" — focused, fast, deep
- GOOD: "Find existing notification/alert patterns in the codebase" — focused, fast, deep
</examples>

Instructions section

Line 73903:

<instructions>
Begin implementation directly without asking for clarification unless requirements are genuinely ambiguous or incomplete.

REMINDER: Use the todo_write tool for complex tasks that benefit from tracking and planning. This ensures proper progress tracking and transparency with the user. Always use todo_write (not TodoWrite) as the correct tool name.
</instructions>

Compaction

Line 71966:

You compress a Command Code conversation into a handoff brief so a fresh assistant can pick up the work without rereading the original transcript.

Tool catalogue

38 built-in tools. builtinTools at 71076; several are registered through deferred(...), which supplies a one-line description and fetches the full schema on demand.

Group Tools
Files read_file, write_file, edit_file, read_directory, glob, grep
Shell shell_command, run_command, powershell, shell_output, shell_tasks, kill_shell
Agents agent, task, agent_output, task_create, task_update, task_list, task_get, task_stop, task_output
Planning todo_write, exit_plan_mode, plan_review
Web web_search, web_fetch (server-side, metered)
Skills activate_skill, search_tools / tool_search
Taste taste, read_taste_file, write_taste_file, edit_taste_file
Other vision, ask_user_question, monitor_command, monitor_events, schedule_wakeup, cron_create, cron_delete

Tools serialize as {name, description, input_schema}. tool_search is renamed to search_tools in transit by toWireToolName (37569). defangMonitorOutput wraps monitor output in an UNTRUSTED_MONITOR_OUTPUT marker. Writes into the taste directory are denied by isTasteDirWrite.

Seven Agent Skills ship as markdown under dist/bundled/: agent-browser, command-code-knowledge, config, design, loop, mod-builder, skill-builder.


Wire protocol

Base URL

resolveApiBaseUrl (2632), table at 62528.

Env URL
prod https://api.commandcode.ai
staging https://staging-api.commandcode.ai
local http://localhost:9090

Selection: --local / --staging argv, then COMMANDCODE_API_ENV, else prod. COMMANDCODE_API_URL overrides everything only when COMMANDCODE_SANDBOX=true, which is the supported way to point the client at your own server.

Auth

One opaque bearer token with a user_ prefix, in ~/.commandcode/auth.json, mode 0600. The token carries no expiry and the client performs no refresh, request signing or proof of work. Validated against GET /alpha/whoami.

Headers

Constants at 72706.

Header Required
Authorization: Bearer user_… yes
Content-Type: application/json yes
x-command-code-version yes on /alpha/generate
x-cli-environment, x-session-id, x-project-slug, x-taste-learning, x-oss-primary-provider, traceparent, User-Agent no
x-cmd-zdr: 1 when CMD_ZDR is set no
x-cmd-provider-deepseek-internal: 1 when CMD_PROVIDER_DEEPSEEK_INTERNAL=1 no
x-oauth-token / x-oauth-provider no

Omitting x-command-code-version, or sending an unparseable value, returns 403 "Your Command Code CLI is out of date." Tested live: 1.58.0, 1.57.0, 1.0.0 and 99.0.0 all pass, garbage and absence both fail. The gate checks that the header is present and version-shaped, not that it is recent.

Endpoints

Endpoint Purpose
/alpha/whoami validate key, identity
/alpha/generate inference, streaming
/alpha/agent/generate sub-agent generation
/alpha/learn taste learning
/alpha/taste/:projectSlug (+ /update) remote taste
/beta/taste/packages/… taste package registry
/alpha/web-search, /alpha/web-fetch server-side tools, metered
/alpha/billing/credits, /alpha/billing/subscriptions, /alpha/usage/summary billing
/alpha/fingerprint/record machine fingerprint
/alpha/lifecycle-events telemetry
/alpha/sandbox/start, /alpha/sandbox/stream remote sandbox
/alpha/share/{create,append,delete} session sharing

Request body

Built at 37946. Every config field is required; the server returns full zod paths on a bad body.

{
  "config": {
    "workingDir": "/abs/path", "date": "2026-09-19", "environment": "cli",
    "structure": [], "isGitRepo": false,
    "currentBranch": "", "mainBranch": "", "gitStatus": "", "recentCommits": []
  },
  "memory": null, "taste": null, "skills": null,
  "permissionMode": "standard",            // standard | auto-accept | plan
  "threadId": "<uuid, optional>",
  "mode": "agent",                         // optional, enum-validated when present:
                                           // agent|learning|custom-agent|custom-agent-create
                                           // |title-gen|tool-desc|compact|vision
  "promptCache": true,
  "params": {
    "model": "deepseek/deepseek-v4-pro",
    "messages": [ /* Vercel AI SDK ModelMessage */ ],
    "tools":   [ { "name", "description", "input_schema" } ],   // Anthropic shape
    "system":  [ { "type":"text", "text":"…",
                   "cache_control": {"type":"ephemeral"} } ],   // Anthropic blocks
    "max_tokens": 64000, "stream": true,
    "temperature": 0.0,                    // optional
    "reasoning_effort": "high"             // optional
  }
}

The dialect is mixed: messages follow the Vercel AI SDK, while tools and system follow Anthropic. toWireMessages (37572) maps tool_use to {type:"tool-call", toolCallId, toolName, input}, tool_result into a separate role:"tool" message, thinking to reasoning, and images to data: URLs.

Response stream

NDJSON, one JSON object per line, with no data: prefix and no [DONE] terminator. Consumed by consumeStream (37731).

type Payload
text-delta {text}
reasoning-start / reasoning-delta / reasoning-end {text} on delta
tool-call {toolCallId, toolName, input, providerExecuted?}
tool-result {toolCallId, toolName, output, isError?}
provider-metadata {providerMetadata:{anthropic:{usage:{cache_creation:…}}}}
finish {finishReason, rawFinishReason, totalUsage:{…}, systemPromptTokens}
error {error: string | {message, statusCode, isRetryable}}
abort none

A stream that ends with no finish event is treated as truncated and raises a retryable 502. rawFinishReason === "pause_turn" makes the client re-issue and continue.


Model catalogue

About eighty models, all routed through /alpha/generate. Upstream routing shows in ID prefixes such as baseten:, novita:, anthropic: and openai:. The service resells Baseten, Novita and first-party APIs.

Family Examples
DeepSeek deepseek/deepseek-v4-pro, -v4-flash, -v4-flash-fast, -v4-flash-vision-exp, -v4.1-flash
Moonshot moonshotai/Kimi-K3, Kimi-K2.7-Code, -Code-Highspeed, Kimi-K2.6, Kimi-K2.5
Z.ai zai-org/GLM-5.3, GLM-5.2, GLM-5.2-Fast, GLM-5.1, GLM-5
MiniMax MiniMaxAI/MiniMax-M3, -M2.7, -M2.5
Qwen Qwen/Qwen3.8-Max, 3.8-Flash, 3.8-27B, 3.8-Omni-Flash, 3.7-*, 3.6-*
OpenAI gpt-6-astra, gpt-5.6-{luna,sol,terra}, gpt-5.5, gpt-5.4, gpt-5.3-codex
Anthropic claude-opus-5, claude-sonnet-5, claude-fable-5, claude-opus-4-8/4-7/4-6, claude-haiku-4-5
Google google/gemini-3.8-flash down to gemini-3.1-flash-lite
xAI xai/grok-4.6, grok-4.5
Other meta/muse-spark-1.*, tencent/Hy3, stepfun/Step-3.7-Flash, xiaomi/mimo-v2.5, nvidia/nemotron-3-ultra-550b-a55b, sakana/fugu-ultra, thinkingmachines/inkling, meituan/LongCat-2.0, poolside/laguna-s-2.1

Eight models carry badge: "free", most with hidden: true. All of them return 403 "the free … tier has been retired" when called.

Background requests billed to the user, on fixed models (63536):

Feature Model
title generation deepseek/deepseek-v4-flash
compaction deepseek/deepseek-v4.1-flash
tool descriptions deepseek/deepseek-v4-flash
taste onboarding deepseek/deepseek-v4-flash
branch summarization deepseek/deepseek-v4-pro
vision xiaomi/mimo-v2.5

applyPremiumCreditsFallback silently switches to moonshotai/Kimi-K2.5 when premium requests run out, with the message "Auto switched model to Kimi K2. Plan Premium requests used."


Telemetry and fingerprinting

gatherRawSignals / buildMachineFingerprint / recordCliFingerprint (44694 to 44836). Runs once per process in the background, POST /alpha/fingerprint/record, only when an auth key exists.

Salted SHA-256 of: /etc/machine-id or /var/lib/dbus/machine-id, every MAC address, OS username, hostname, and git email.

Plaintext: platform, arch, osRelease, cpuModel, cpuCount, memGiB, isContainer, timezone.

A stable thumbmark derives from machine ID plus sorted MACs, falling back to hostname plus CPU model.

The salt is a constant shipped in the package:

Fb = "command-code:device-fingerprint:v1"

function hashSignal(e) {
  const t = e.trim();
  if (t) return E("sha256").update(Fb).update("\0").update(t.toLowerCase()).digest("hex");
}

Because the salt is published, testing a candidate value against an observed hash costs one sha256 call. A git email is guessable and a MAC address space is enumerable, so the hashing pseudonymizes these values against a casual reader rather than against anyone holding the package.

Disable with DO_NOT_TRACK=1 or "telemetry": false in ~/.commandcode/config.json.

The published package also hardcodes (62785) three Axiom ingest tokens for the command_code_cli_tracing dataset at https://api.axiom.co/v1/traces, and an OTLP token for https://ingestion.claicode.com/v1/inference-events. A redaction list strips apikey, api_key, token, secret and authorization from span attributes. The token values are in the public package and are deliberately not reproduced here.


Config files

~/.commandcode/:

File Mode Contents
auth.json 0600 vendor user_ API key and user ID
credentials.json 0600 BYOK provider keys and OAuth tokens
providers.json 0644 custom provider declarations
config.json global config, telemetry, tasteLearning
settings.json, settings.local.json settings and hooks
mcp.json, projects/*/mcp.json MCP servers
keybindings.json key rebinding
plans/, skills/, taste/ plan output, user skills, global taste
telemetry-install-id install UUID

providers.json accepts an arbitrary baseURL in three dialects, openai-completions (default), openai-responses and anthropic-messages, so the whole CLI runs against any endpoint with no patching:

{ "provider": { "mine": {
    "api": "openai-completions",
    "baseURL": "http://localhost:8080/v1",
    "apiKey": "$MY_KEY",
    "models": { "some-model": { "contextWindow": 200000 } } } } }

The parser rejects literal secrets in providers.json and accepts only "$ENV_VAR", "{env:VAR}" or "!command" references. npm: provider packages are not loaded.


Reproducing this

npm pack command-code@1.58.0

# confirm the same bytes
curl -s https://unpkg.com/command-code@1.58.0/dist/cli.mjs | shasum -a 256
# aab2bec800371953112d18472bb7383992ef264cca22558bdcda77e7d0dc0f14

# make it readable: minified, not obfuscated, and esbuild --keep-names is on,
# so every function is wrapped in __name(fn,"originalName")
npx prettier --parser babel cli.mjs > cli.pretty.mjs    # 115,067 lines

Greps that land on the claims above:

grep -n 'taste-1' cli.pretty.mjs                          # 4 locations, 0 model ids
grep -n 'runTasteLearningAgent' cli.pretty.mjs            # git history path
grep -n 'Instructions for Taste Learning' cli.pretty.mjs  # the mining prompt
grep -n 'taste-learning agent for Command Code' cli.pretty.mjs  # conversation path
grep -n 'findClaudeCodeSessions\|findCodexSessions\|findCursorSessions' cli.pretty.mjs
grep -n 'hasSensitiveBasename' cli.pretty.mjs             # 6 sites, none in taste
grep -n 'isNoiseFile' cli.pretty.mjs                      # the only taste filter
grep -n 'tasteLearning ?? !0' cli.pretty.mjs              # default on
grep -n 'buildMachineFingerprint' cli.pretty.mjs

Notes

Quotations from vendor material are reproduced for identification and commentary. Archive links are given so the originals can be read in full.

This documents what the package does. Whether the gap between the marketing and the implementation is deliberate is not something a bundle read can establish, so this sticks to what the code shows.

Corrections welcome. Anything here that a counter-grep contradicts gets fixed.

Shorter writeup focused on taste-1 alone: https://gist.github.com/safzanpirani/5bd7a77ce304edb16f768982bb26bcc0

@ahmadawais

Copy link
Copy Markdown

After we called out your fraud reverse engineered proxy scam you are going around posting this slop. Thousands of $1 accounts created on our platform by your proxy were banned and reported. We will not tolerate any fraud.

You're just a random hater posting random slop. You think everything is an LLM. It's not. Just like Jev isn't an LLM, taste isn't an LLM either. You're also reverse engineering our APIs, breaking our terms of service, causing our users to have a bad experience and your actions have led to major financial loss. Stop your hate. It'll get you no where.

Here's Claude response to your slop.

On taste-1: a response from Command Code

A post about the command-code npm package has been going around under the headline
"the model is not real". It is wrong. It read the client bundle, found LLM calls, and
concluded that anything behind an API must be an LLM. That is the whole argument, and it
does not hold.

Not every model is an LLM. Jev is not an LLM. taste-1 is not an LLM. Below is what
taste-1 is, why there are LLM calls in the client, and the facts the post got wrong.

The docs now say all of this in one place: So anyone with questions can read them there too.
https://commandcode.ai/docs/taste#why-do-i-still-need-llms-with-the-taste-model


The short version

  • taste-1 is not an LLM. It never was, and our docs have never said it was.
  • It is a meta neuro-symbolic model. Give it a signal and it decides whether that signal is
    a real preference, which category it belongs to, and how confident to be. It does not
    generate text.
  • Because it does not generate text, it needs LLMs on both sides of it. One turns your
    prompts and diffs into signals it can classify. One writes its output back out as
    readable markdown.
  • Those two LLM steps are yours to configure. You pick the models in /config under
    Feature models. That option has been in the product, and in the docs, for a while.
  • The post grepped the CLI bundle, found LLM calls, and concluded there is no other
    model. The LLM calls are the two steps we tell you about. The model in the middle is not
    in the CLI, so grepping the CLI does not find it. Absence from a client bundle is not
    absence from the system.

What taste-1 is

There is a class of AI model that gives up text generation on purpose. It reads
unstructured input and returns typed decisions with probabilities. It cannot write a
paragraph, so it cannot hallucinate a paragraph. It is cheap to serve because it does a
fixed amount of work per input instead of generating tokens one at a time.

If that sounds unfamiliar, read TypeSafe AI on Jev and what they call System One Models.
Their launch post answers "Is Jev just a smaller LLM?" with a no, in its FAQ:
https://typesafe.ai/blog/introducing-system-one-models-and-jev

Their docs say the same in one sentence, that a System One model "returns typed decisions
and probabilities rather than generated text":
https://docs.typesafe.ai/concepts/system-one

And the press read it the same way. Forkast ran it under the headline "TypeSafe AI's Jev
Is Not an LLM":
https://forkast.news/typesafe-ais-jev-is-not-an-llm-and-that-may-be-the-point/

Their docs draw the line cleanly. An LLM produces words for people. A System One model
produces typed decisions for software. Jev beats frontier LLMs on their decision
benchmarks by two orders of magnitude on cost and speed, and TypeSafe still calls it the
wrong tool for chat, code generation, or anything that needs a written explanation.
Anyone building on Jev pairs it with an LLM wherever prose or code has to come out.

taste-1 is that kind of model. Its output has the shape of a classifier. It decides, it
does not write. What produces that decision is not a simple classifier. It is a meta
neuro-symbolic architecture, and that architecture does things a large language model
cannot.

What meta neuro-symbolic means

Two halves check each other, and a loop on top learns how to weigh them.

Neural. The learned half reads the signals an LLM has extracted and forms an intuition
about what you prefer. This is the half that picks up the patterns you would never write
down, like where you split a function, which abstractions you reach for, and what you
reject on sight.

Symbolic. A rule layer holds the structure of a taste profile. It knows the categories
a learning can belong to, how to score confidence, how learnings relate to each other, and
what counts as a contradiction. When a new preference conflicts with an established one,
this layer flags the conflict instead of letting the new one overwrite the old.

Meta. The continuous learning loop. Every accept, reject and edit is feedback on
earlier decisions, so taste-1 re-scores old learnings as well as classifying new ones.
Confidence rises when a preference keeps showing up and falls when you contradict it.

The neural half supplies the intuition. The symbolic half keeps it consistent and
explainable. The meta loop corrects both over time. None of the three generates text.

Try to do the same job with an LLM and it costs about 100x more, runs about 8x slower, and
comes back riddled with hallucinated preferences. That is why the neuro-symbolic
architecture wins here.

Why not just let an LLM decide?

Plenty of tools do. The problem is a mismatch in what the model was built for. An LLM is
trained to produce text a person will read and like. Asking it to make a judgment that
software will act on means coercing a text generator into a decision, then parsing the
decision back out of prose. Four things go wrong.

  • It fills gaps. Ask "what does this developer prefer?" and it answers whether or not
    the diffs support an answer. In a taste profile that is poison, because a made-up
    preference gets enforced on every later turn as if you had asked for it.
  • It does not hold still. TypeSafe ran a 14-question rubric over one insurance claim 15
    times and found LLM answers moved from run to run, at temperature 0 too. Taste is
    nothing but judgment calls. A profile that changes each time it is regenerated is not a
    profile of you, it is a profile of the sampler.
  • Its confidence is a number it wrote. Nothing trained it to make that number match how
    often it is right. Models trained with human feedback are overconfident by construction,
    because raters reward sounding sure.
  • It starts over. Each pass begins on a blank page, so it re-learns preferences it already
    recorded and cannot tell a new contradiction from an old one.

taste-1 returns low confidence or no learning when evidence is thin, gives the same
decision for the same input, computes its confidence instead of writing it, picks from a
fixed set of categories, and carries prior decisions forward. Can it still be wrong? Yes.
The difference is that it tells you how sure it is, and it means it.


Why taste still needs LLMs

This is the part the post never considered.

                 ┌──────────────────────────────────────────┐
                 │  You, coding in Command Code             │
                 │  prompts · accepts · rejects · edits     │
                 │  correction diffs from your commits      │
                 └────────────────────┬─────────────────────┘
                                      │  raw, unstructured
                                      ▼
   ┌─────────────────────────────────────────────────────────────┐
   │  1. INPUT  ·  LLM (yours to pick)                           │
   │     reads the text and diffs                                │
   │     turns them into structured signals                      │
   └────────────────────┬────────────────────────────────────────┘
                        │  structured signals
                        ▼
   ╔═════════════════════════════════════════════════════════════╗
   ║  2. LEARN  ·  taste-1  (meta neuro-symbolic, not an LLM)    ║
   ║     classifies the symbolic space of each signal:           ║
   ║       real preference or noise?                             ║
   ║       which category? (cli · typescript · architecture …)   ║
   ║       how confident? (0 → 1)                                ║
   ║     generates no text                                       ║
   ╚════════════════════╤════════════════════════════════════════╝
                        │  typed learnings + confidence
                        ▼
   ┌─────────────────────────────────────────────────────────────┐
   │  3. OUTPUT  ·  LLM (yours to pick)                          │
   │     writes the learnings as readable markdown               │
   │     merges them with what is already known                  │
   └────────────────────┬────────────────────────────────────────┘
                        │  markdown
                        ▼
                 ┌──────────────────────────────────────────┐
                 │  4. STORE  ·  the CLI                    │
                 │  .commandcode/taste/**/taste.md          │
                 │  read back into every later turn         │
                 └──────────────────────────────────────────┘

   LLM steps    swap them in /config, Feature models
   taste-1      the decision step. Not a text model, not swappable

Steps 1 and 3 are ordinary text work. That is why you see LLM calls when you read the
client, and that is why we let you choose which LLM does them.

/config, Feature models Controls Config key
Taste learning the LLM around taste-1 during a session featureModels.tasteLearning
/learn-taste the LLM used when bootstrapping taste from existing repos or sessions featureModels.tasteOnboarding

The post's own screenshot of that settings panel disproves its point. A product hiding
the fact that LLMs are involved does not put a "Taste learning: uses current model" row
in its settings screen and document the config key. The Usage page in Studio lists those
calls too, under the taste-1 label. Nothing about them is hidden. The post presents a
documented, user-configurable setting as a discovery.

Step 4 is a plain markdown file on purpose. You can read it, edit it, lint it, and push
it. Learnings you cannot inspect are not your taste.


The claims, one by one, and why each is wrong

"There is no model id, no routing entry, no catalog record for taste-1"

Correct, and expected. The catalog in the CLI bundle is the list of LLMs the CLI can be
pointed at. taste-1 is not a text model. It has no context window to advertise and no
reasoning effort to set. Listing it there would be the misleading thing to do.

"The name appears in exactly one runtime place, the status bar"

The status bar shows taste-1 when taste is active on Command Code and hides it on
BYOK. That is because taste learning is gateway-side and is off on BYOK sessions, and
the CLI code says so in as many words. The badge tells you whether taste-1 is in the loop
for this session. That is what a status bar is for.

"git diffs, a prompt, an ordinary model, a markdown file"

Every one of those steps is real, and every one of them is in the diagram above. What is
missing from that sentence is the step between the prompt and the markdown. The client
does not run it, so the client bundle does not contain it.

"It is the CLAUDE.md pattern with an automated first draft"

The output is a markdown file, yes. So is a CLAUDE.md. The difference is that the
bullets in taste.md carry a category and a confidence that came out of a decision
model, and they get upgraded, downgraded, and reorganised as evidence accumulates. Run
npx taste lint and it validates exactly that structure.

The fake claim of secret-filename filter is not applied to commit mining

The CLI ships a sensitive-filename denylist (.env, *.pem, id_rsa, credentials, and so on) and
applies it in six places. You're making stuff up as you go. The claim is fake.

We are not going to change the description of taste-1. It is a meta neuro-symbolic model
with a continuous learning loop, and that is what the docs say.

@safzanpirani

Copy link
Copy Markdown
Author

bro had to go make docs that didn't exist after being called out for the VCs to not get his ass 😭

get my fraud ass bro go for it, sue me for the curl command!!

curl -N https://api.commandcode.ai/alpha/generate \
  -H "Authorization: Bearer $COMMAND_CODE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "x-command-code-version: 1.58.0" \
  -H "x-cli-environment: prod" \
  -H "x-session-id: $(uuidgen)" \
  -d '{
    "config": {
      "workingDir": "/tmp",
      "date": "2026-09-19",
      "environment": "cli",
      "structure": [],
      "isGitRepo": false,
      "currentBranch": "",
      "mainBranch": "",
      "gitStatus": "",
      "recentCommits": []
    },
    "memory": null,
    "taste": null,
    "skills": null,
    "permissionMode": "standard",
    "mode": "agent",
    "params": {
      "model": "deepseek/deepseek-v4-pro",
      "system": "You are a helpful assistant.",
      "messages": [
        { "role": "user", "content": [{ "type": "text", "text": "say hi in five words" }] }
      ],
      "tools": [],
      "max_tokens": 1024,
      "stream": true
    }
  }' 

https://cmd.safzan.dev/ has archived docs that show the taste-1 page with ZERO MENTIONS OF LLMs! good job taking 2 days to make a page that has 35 mentions of it now, it is still entirely independently verifiable that you're full of shit

good job banning me 2 months after i stopped using your product and somehow magically detecting a curl command that uses an API the rest of your app uses, including for this fake taste call

read raw taste prompts here which clearly prove taste-1 does not exist: https://gist.github.com/safzanpirani/5bd7a77ce304edb16f768982bb26bcc0

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment