Teaching Command Code to learn how you write code
We're releasing a new capability for Command Code: taste driven development. Command Code now learns from your accepts, rejects, and edits to generate code that matches how you actually work.
The problem we set out to solve
AI-assisted coding has a paradox. The code is usually correct. It's rarely yours.
Every developer builds up years of micro-decisions: how they name variables, when they extract helpers, which patterns they reach for, how they structure tests. This accumulated intuition - what we've been calling "coding taste" - is invisible to language models. They optimize for statistical plausibility, not for the specific choices that make code feel right to you.
The result is a frustrating loop:
Agent writes code, you fix it, agent doesn't learn, you fix it again.
We wanted to break this loop. To make Command Code not just a tool that generates code, but a collaborator that learns how you write code and adapts its suggestions accordingly.
What we built
Command Code now observes how you interact with its suggestions. Every accept is a signal. Every rejection is a signal. Every edit you make after accepting is a signal.
1Your Feedback Loop
2==================
3
4 You write prompt
5 |
6 v
7 Command Code generates
8 |
9 +----+----+
10 | |
11 v v
12 Accept Reject Edit
13 | | |
14 +----+----+--------+
15 |
16 v
17 Learn & Update Taste
18 |
19 v
20 Next generation improvesOver time, Command Code builds a model of your preferences. Not as static rules you have to maintain, but as learned constraints it applies automatically.
1# Before: Generic output
2export default function handler(req, res) {
3 var data = req.body
4 res.status(200).json({data: data})
5}
6
7# After learning your patterns
8export const POST = async (req: Request): Promise<Response> => {
9 const data = await req.json()
10 return Response.json({ data })
11}Same prompt. Different output. Command Code learned you prefer named exports, strict TypeScript, modern APIs, and async/await.
Why this isn't just another rules file
Developers have tried solving this with rules files, style guides, and agent instructions. These help, but they have a fundamental limitation: they decay.
Rules are a snapshot of what you remembered to write down. Your codebase evolves. Your preferences shift. The rules stay frozen.
1Rules vs Learned Preferences
2=============================
3
4RULES (Static) TASTE (Dynamic)
5----------- ---------------
6 Day 1 Day 1
7 [Rules] [Taste v1]
8 | |
9 Day 30 Day 30
10 [Same Rules] [Taste v30]
11 (Outdated) (Evolved)| Rules | Learned preferences | |
|---|---|---|
| Source | What you write down | Observed from your behavior |
| Updates | When you remember | Every session |
| Granularity | Broad guidelines | Micro-decisions |
| Over time | Drifts from reality | Compounds accuracy |
We're not deprecating rules. They remain useful for team-wide standards. But individual coding taste is too granular and too dynamic to maintain manually.
The technical approach
This work builds on our research into making Command Code more responsive to implicit user feedback. The core insight: your edits contain information about what you wanted but didn't get.
1How Taste Learning Works
2=========================
3
4 Generated Code
5 |
6 v
7 You Edit It
8 |
9 v
10 Extract Pattern
11 (What changed?)
12 |
13 v
14 Update Taste Model
15 (Add to preferences)
16 |
17 v
18 Next Time
19 (Apply learned pattern)We treat this as a preference learning problem. Command Code maintains a lightweight representation of your coding patterns: which constructs you favor, how you structure code, what you consistently change after generation. This representation updates continuously and conditions Command Code's outputs without requiring explicit configuration.
The learned preferences are transparent. You can inspect them in .commandcode/taste/, edit them directly, or reset them entirely. We think this interpretability matters. You should be able to understand why Command Code made a particular choice, and correct it if it learned something wrong.
What we're seeing
Early users report a noticeable shift after about a week of use:
- Fewer correction loops. Code comes out closer to what they wanted the first time.
- Code reviews feel more familiar. The generated code looks like code you'd have written.
- Less context-switching. Less mental overhead translating between "how Command Code writes" and "how I write."
We're being careful not to overstate this. The system learns patterns, not intentions. It won't anticipate architectural decisions you've never shown it. And it's still early. We expect meaningful improvements as we iterate.
Getting started
Adaptive preferences are available now in Command Code. No configuration required. Just use Command Code as you normally would, and it will begin learning from your feedback.
1The Taste Learning Timeline
2============================
3
4Week 1: Generic output, some fixes needed
5 [==== ] 40% match
6
7Week 2: Patterns emerging, fewer edits
8 [======== ] 60% match
9
10Week 3: Recognizes your style
11 [============ ] 80% match
12
13Week 4+: Feels like your collaborator
14 [==============] 90%+ match1cmd "add a healthcheck endpoint"Accept what works. Edit what doesn't. Over time, the gap narrows.
If you want to inspect or edit what Command Code has learned, check .commandcode/taste/ in your project directory. You can also share preference profiles across projects or with teammates who work similarly.
What's next
This is a step toward something we think matters: AI tools that adapt to you rather than forcing you to adapt to them.
We're exploring how this approach extends beyond coding. To writing, analysis, and other domains where personal style and accumulated expertise should shape the output. The underlying principle is the same: observe, learn, apply.
For now, we're focused on making Command Code feel less like a generic tool and more like a collaborator who's worked with you before.
You'll read more about it when we launch Command Code in Feb 2026.
Try it today at CommandCode.ai start with npm i -g command-code.
We'd love to hear what you think.
