Taste
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.

- Continuously learning side learns the texture of your code (explicit & implicit feedback).
- Meta Neuro-Symbolic AI model
taste-1enforces the invisible logic of your choices. - Reflective Context Engineering of a self-aware RL feedback loop to build skills.
✓ 10x faster coding, 2x faster code reviews, 5x fewer bugs.
The taste-1 model is the core of our taste architecture. To build your taste profile it:
- 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 — a continuous learning loop that never goes stale
Unlike traditional coding assistants that rely on generic best practices, Taste builds a personalized model of your team's code review patterns, style preferences, and architectural choices. It observes how you write, review, and merge code to develop an intuitive understanding of your quality standards and design philosophy.
Once installed, just start coding. Taste learning runs in the background and builds your profile from every interaction.
Taste sharing and portability
The architecture of Taste is fundamentally built around the principle that taste should be transferable and composable. Your learned preferences aren't locked in a single project. They can be used across all your projects, shared with your team, and composed together to match your workflow. You can view and manage everything in the Command Code Studio.
Taste learning runs in the background, learning from your interactions. You can turn it on or off at two scopes — per project and for your user account — from the /taste panel inside Command Code.
Changing settings from /taste
Run /taste to open the Taste Settings panel. It has two rows:
- This project — writes
.commandcode/settings.json(committed, shared with your team) - User — writes
~/.commandcode/config.json(applies to all your projects)
Where taste is set
Command Code checks these files in order of priority to determine whether taste learning is enabled:
| Priority | Set in | Affects | Shared with team? |
|---|---|---|---|
| 1 | .commandcode/settings.local.json | local setup only | No, personal, not committed |
| 2 | .commandcode/settings.json | this project | Yes, committed |
| 3 | ~/.commandcode/config.json (User row) | all your projects | — |
| 4 | (unset) | — | on by default |
To disable taste learning for a project, add the following to .commandcode/settings.local.json:
The override in .commandcode/settings.local.json will take precedence over the project-level setting.
Sharing and managing taste profiles is as simple as using Git. The npx taste CLI tool is your primary interface for pulling, pushing, listing, and composing taste models, which you can view in the Command Code Studio.
This unified interface lets you push your learned preferences to the Command Code Studio, pull taste from teammates or the community, and compose multiple taste profiles to match your workflow.
Push taste to studio
You can push your taste to the Command Code Studio and share it with your team.
Push taste to studio
Pull taste from studio
You can pull a taste profile from the Command Code Studio to your different projects.
Pull taste from studio
List all taste profiles
You can list all the taste profiles available in the Command Code Studio.
List all taste profiles
Open a specific taste profile
You can open a specific taste profile in Command Code Studio.
Open a specific taste profile
This pushes your entire project's taste to commandcode.ai/username/taste, and pulls taste from remote to your local project:
Push project taste to remote
Pull taste from remote
A taste package is a collection of learnings organized by category (e.g., cli, typescript, architecture). Each package contains a taste.md file with preferences and patterns Command Code has learned.
Taste packages are of three types:
Project
Project specific taste packages are automatically learned and stored in your project.
- Path:
.commandcode/taste/ - Use case: Learnings unique to this codebase
Global
Your personal taste packages accessible across all projects on your machine. Use the -g flag to push/pull global packages.
- Path:
~/.commandcode/taste/ - Use case: Your personal taste that follows you across projects
Remote
Taste packages on cloud under your profile at commandcode.ai.
- Path:
commandcode.ai/username/taste - Use case: Team sharing, backup, sync across machines, public packages
File structure
File structure for project and global taste packages:
Project packages
Global packages
You can either push/pull your entire project taste or individual packages.
Project taste (push --all)
When you use push --all, Command Code pushes your entire project's taste as a single unit:
Push project taste
- Bundles all packages from your project together
- Project name is derived from your current directory
- Pushed to remote under your namespace
Individual package (push <package>)
When you push a specific package, only that single package is uploaded:
Push individual package
- Pushes one package at a time
- You choose the namespace (personal or organization)
- Great for sharing specific learnings with others
Complete reference for all npx taste commands. Manage your taste packages across project, global, and remote.
| Command | Description |
|---|---|
npx taste push | Push project or individual packages to remote or global |
npx taste pull | Pull packages from remote or global |
npx taste list | List all available packages |
npx taste lint | Validate package format and structure |
npx taste open | Open packages in your default editor |
taste push
Push taste packages from your local project to remote or global.
Basic usage
Options
| Option | Short | Description |
|---|---|---|
--all | Push entire project taste (all packages bundled together) | |
--global | -g | Push to global (~/.commandcode/taste) |
--overwrite | Replace target completely without merging | |
--public | Make package publicly discoverable (remote only) |
Targets
Remote is the default — pushes to cloud under your profile at commandcode.ai/username/taste (use case: team sharing, backup, sync across machines, public packages). Use -g to push to your global packages at ~/.commandcode/taste/ instead (use case: personal taste that follows you across projects).
Push to remote
Push to global
Examples
Push project
Bundles all your project's taste packages and uploads them to commandcode.ai/username/taste. Your team can then pull with npx taste pull username/project-name.
Push individual
Prompts you to select a namespace (personal or organization), then uploads only the cli package. If you have push access to multiple accounts, you get prompted.
Push with namespace
Uploads the cli package directly to the myteam namespace without prompting.
Push public
Uploads the package and makes it publicly discoverable by other Command Code users.
Overwrite
Completely replaces the remote package without merging. By default, push intelligently merges learnings.
Merge behavior
By default, taste push intelligently merges your local learnings with existing remote/global content:
- New learnings are added
- Updated learnings (changed confidence) are updated
- Identical learnings remain unchanged
Use --overwrite to skip merging and completely replace the target.
Output
Example output
Individual package output
taste pull
Pull taste packages from remote or global to your project.
Basic usage
Options
| Option | Short | Description |
|---|---|---|
--global | -g | Pull from global (~/.commandcode/taste) |
--all | Pull all packages (global only) | |
--overwrite | Replace local package without merging |
Targets
Remote is the default — pull from cloud under your profile or others' profiles at commandcode.ai/username/taste (use case: get taste from teammates, sync across machines, pull public packages). Use -g to pull from your global packages at ~/.commandcode/taste/ instead.
Pull from remote
Pull from global
Examples
Pull project
Downloads all taste packages from teammate/awesome-project to your local project.
Pull individual
Downloads only the cli package from ahmadawais's profile.
Pull from global
Copies the cli package from ~/.commandcode/taste/ to your current project.
Pull all global
Copies all packages from your global to the current project.
Overwrite
Completely replaces your local cli package with the remote version.
Merge behavior
By default, taste pull intelligently merges remote learnings with your local content:
- New learnings from remote are added locally
- Updated learnings (changed confidence) are updated
- Identical learnings remain unchanged
Use --overwrite to skip merging and completely replace local content.
Output
Example output
taste list
List all available taste packages.
Basic usage
Options
| Option | Short | Description |
|---|---|---|
--global | -g | List packages from global (~/.commandcode/taste) |
--remote | List packages from your remote profile at commandcode.ai |
Scopes
By default, taste list shows packages in your current project's .commandcode/taste/ directory. Use -g to list your global packages at ~/.commandcode/taste/, or --remote to list packages stored on cloud under your profile at commandcode.ai/username/taste.
List project packages
List global packages
List remote packages
Output
The command displays:
- Package name: The taste package identifier
- Public badge:
[public]for publicly discoverable packages - Stats: Star count (★) and download count (↓) for public packages
- Learning count: Number of learnings in the package
- Last updated: When the package was last modified
Example output
Remote output example
taste lint
Validate taste file format and structure. This command checks your taste files for errors and warnings before pushing.
Basic usage
Arguments
| Argument | Description |
|---|---|
[package] | Package name to lint. Optional if using --all. |
Options
| Option | Short | Description |
|---|---|---|
--global | -g | Lint packages from global (~/.commandcode/taste) |
--all | Lint all packages |
Examples
Lint single package
Validates the cli taste package in your local project.
Lint all local
Validates all taste packages in your local project's .commandcode/taste directory.
Lint global
Validates the cli package from your global.
Lint all global
Validates all packages in your global at ~/.commandcode/taste.
Output
The command provides detailed validation results:
Example output (valid)
Example output (with errors)
What gets validated
| Check | Description |
|---|---|
| Markdown structure | Proper header hierarchy and formatting |
| Required fields | Presence of required metadata and sections |
| Confidence values | Values must be between 0 and 1 |
| Header format | Correct header syntax and naming |
| File encoding | Valid UTF-8 encoding |
Behavior
- Validates both main
taste.mdand category-specific taste files - Supports automatic header migration for legacy format files
- Errors indicate problems that must be fixed before pushing
- Warnings indicate potential issues but don't block operations
taste open
Open a taste package in your default editor. This command provides quick access to edit your taste files directly.
Basic usage
Arguments
| Argument | Description |
|---|---|
<package> | Required. The name of the package to open. |
Options
| Option | Short | Description |
|---|---|---|
--global | -g | Open package from global (~/.commandcode/taste) |
Examples
Open local
Opens the cli taste package from your local project in your default editor.
Open global
Opens the cli package from your global at ~/.commandcode/taste.
Output
Example output
Editor configuration
The command uses your system's default editor set via the $EDITOR environment variable. If not configured, you'll see setup instructions:
Editor setup
After adding the export, restart your terminal or run source ~/.zshrc.
Behavior
- Opens the taste file in your default editor
- For category-specific files: Opens at line 1
- For main
taste.mdfiles: Searches for the category heading and opens at that line - Automatically navigates to the correct location in the file
Share your project taste with the team
Push your project taste
Push all your project's learnings to remote.
Push project
Team members pull
Others can pull the project taste to their local setup.
Pull from remote
Use your taste across projects (via global)
Push to global
Save a package to your global for use in any project.
Push to global
Pull in another project
In a different project, pull from global.
Pull from global
Backup and sync via remote
Push to your profile
Back up your taste to commandcode.ai.
Push to remote
Access from anywhere
Pull your taste on any machine.
Pull from remote
- Build something cool with Command Code and see your taste in action
- View and manage your packages in the Command Code Studio
- Join our Discord community for feedback, requests, and support.