Command Code
The Taste-Learning Harness · Deep-Dive DD-15 · Course 1
60 minutes · The first harness that learns your coding taste from accept/reject signals and persists it as Markdown
3,500+ stars. $5M seed. Closed-source TypeScript. A fundamentally new feedback model: the diff between generated and kept code becomes a preference that shapes every future output.
Deep-Dives
The thesis — learned preferences, a candidate sixth memory tier
Hermes (DD-08) learns PROCEDURES
Self-evolving skills: how to DO things. Reusable procedures that compound.
Command Code learns PREFERENCES
Self-evolving taste: how you WANT things done. Style constraints that shape every output.
Same compounding-memory insight, applied to a different layer. On Module 4's framework, taste is a candidate sixth tier: learned preferences derived from behavioral signal, distinct from both static memory (what you wrote) and episodic memory (what happened).
The taste loop — the 5-stage verifiable mechanism
| Stage | What happens | Verifiable? |
|---|
| 1. Signal capture | Accept/reject/edit produces a diff (generated vs. kept) | Yes |
| 2. Profile generation | Prompt template turns diffs into preferences | Yes (template exists) |
| 3. Persistence | Plain Markdown at .commandcode/taste/taste.md | Yes |
| 4. Server-side model | Synced to api.commandcode.ai; taste-1 runs hosted | Yes (traffic observed) |
| 5. Sharing | taste push / taste pull (Git-style, Apache-2.0) | Yes |
Honest gap: marketing calls taste-1 "meta neuro-symbolic AI with continuous RL." The only verifiable mechanism is diff-driven Markdown updates + a hosted model. The RL/symbolic internals are not published. Treat the framing as vendor characterization.
Why diff is a better signal than thumbs-up/down
Thumbs up/down
Carries NO information about what was wrong. A thumbs-down tells the system nothing actionable.
Explicit feedback
Requires a SEPARATE action the user would not otherwise perform. Friction; rarely done.
Diff as signal
The user's edit is the GROUND TRUTH of what they wanted. Captured as a side-effect of editing already happening.
The diff is the feedback. No separate feedback action is required. The signal is cleaner, cheaper to capture, and higher-resolution than the alternatives.
Static memory vs. learned memory
Static memory
AGENTS.md, COMMANDCODE.md — what you WROTE. The project's explicit conventions. A new contributor reads this.
Learned memory
.commandcode/taste/taste.md — what the system INFERRED from your behavior. The residue of every accept/reject/edit. The system has already absorbed the team's taste.
The two layers compose. Same compounding insight as Hermes's skills, applied to preferences instead of procedures. Explicit compaction (MemorySelector, CompactAgent) handles long sessions by summarizing, not truncating.
The two novel security surfaces
Surface 1: Preference exfiltration
The taste profile syncs to api.commandcode.ai by design. Your coding patterns leave your machine. For a proprietary codebase, the profile is a distilled representation of how you want code written — itself valuable IP.
Surface 2: Preference poisoning
A poisoned preference COMPOUNDS — it shapes every future output, not just one entry. The same compounding property that makes taste learning valuable makes taste poisoning durable. As-built: no validation gate between inference and persistence.
Both surfaces compound. Ordinary memory poisoning (Module 4.3) persists one bad entry; preference poisoning persists one bad entry that influences every subsequent generation. The taste layer is a higher-stakes write surface than ordinary memory.
Score: 31/60 — wins on memory, loses on transparency
| Module | Score | Key decision |
|---|
| 1 Loop | 4 | React+Ink TUI, ~22 tools, plan/explore subagents |
| 2 Tools | 4 | ~22, design-aware (16+ design verbs) |
| 4 Memory | 4 | learned taste layer + static memory (novel 6th tier) |
| 11 Observability | 2 | OpenTelemetry built in, but obfuscation blocks custom instrumentation |
| 12 Prompt | 3 | closed-source; taste profile is prompt-shaped but not auditable |
Highest on Module 4 (Memory): the taste system is a novel learned-memory layer. Loses points for closed-source distribution — the structural cost across the lower scores.
Architect's verdict & anti-patterns
Build on Command Code when personalization is the primary value and you trust the hosted model. Do not build on it for security-sensitive codebases without understanding what leaves your machine.
"The neuro-symbolic framing means it is safe." Treat it as vendor characterization. Verify the mechanism (diff to Markdown to hosted model) and judge the surfaces on that.
"Taste poisoning is the same as memory poisoning." It is not. Preference poisoning shapes every future output. Treat the taste layer as a higher-stakes write surface; add validation before persistence.
"The hosted model is just a convenience." It concentrates your proprietary signal on someone else's server. Do not deploy where the preference profile is itself the IP.
3 things it does better, 3 things to fix
Does better
- Taste learning — no other harness learns from accept/reject behavior
- Bundled design skills — 16+ design verbs (checkup, smell, review, deslop)
- Model breadth — Claude, GPT-5.x, Gemini, DeepSeek, Qwen, Kimi, GLM
To fix
- Open-source the harness — obfuscation means no audit
- Local taste model — hosted sync is an exfiltration surface
- Add harness-managed learning validation — prevent poisoned preferences compounding
What you can now do
- Explain the taste loop end-to-end and distinguish verifiable mechanism from vendor characterization.
- Articulate static vs. learned memory and place taste as a candidate sixth tier on Module 4.
- Analyze the two novel surfaces — preference exfiltration and preference poisoning — and why both compound.
- Defend "diff as learning signal" over thumbs-up/down and explicit feedback.
- Score Command Code (31/60), explain the wins (Memory) and losses (Observability, Prompt), and judge the closed-source tradeoff for a given deployment.
The lab: build a minimal taste-learning simulation — capture diffs, generate a Markdown profile, then inject a poisoned preference and watch it shape every subsequent output.
Next: DD-16 — ZeroClaw: The Rust Microkernel Harness