Why Command Code?

Why Command Code? https://commandcode.ai/docs/to-be-deleted/why-command-code/ import { generateMetadata } from '@/lib/generate-metadata'; # Why Command Code? Because you're still teaching your coding agent how to code in every session. You've felt the friction when you start coding with coding agents and ask it to build a CLI it gives you yargs because that's what "most developers" use. But assume you don't use yargs you use commander. You spend more time prompt engineering than building. This is the state of AI coding tools right now they have powerful models but zero memory about your preferences and taste. Every other coding agent treats you like a first-day intern. You have to: - Specify your stack: I use pnpm, tsup, and ESM. Not npm in every session. - Nitpick the details: Wait, why are you using yargs? I use commander for building CLIs. - Repeat yourself: In the next session you have to do it all again because the agent remembers nothing. Command Code ends this loop with Taste. We know this pain because we lived it. We watched our own productivity drown in repetitive corrections, teaching the same agent the same preferences day after day, just to get code that almost felt right. Taste is a meta neuro-symbolic reasoning space with continuous reinforcement learning (RL). We combined reasoning with neural intuition to create an invisible architecture of choices. - **Continuously learning** side learns the texture of your code (explicit & implicit feedback) - **Meta Neuro-Symbolic space** enforces the invisible logic of your choices. - **Reflective Context Engineering** of a self-aware RL feedback loop to build skills. Usage & Limits https://commandcode.ai/docs/to-be-deleted/usage-limits/ import { generateMetadata } from '@/lib/generate-metadata'; # Usage & Limits Command Code usage & limits. Pricing https://commandcode.ai/docs/to-be-deleted/pricing/ import { generateMetadata } from '@/lib/generate-metadata'; # Pricing Command Code pricing. Installation Guide https://commandcode.ai/docs/to-be-deleted/installation/ import { generateMetadata } from '@/lib/generate-metadata'; # Installation Guide This installation guide will get you started with Command Code in 90 seconds. ```bash {{ title: 'npm' }} npm i -g command-code ``` ```bash {{ title: 'pnpm' }} pnpm i -g command-code ``` ```bash {{ title: 'yarn' }} yarn global add command-code ``` ```bash cmd auth login ``` ```bash Terminal asks: Would you like to sign in? (y/n) → Type y and hit Enter. ``` ```bash > Open the authentication page? (y/n) → Type y and hit Enter. ``` Command Code Login

Your browser opens to the API keys page. Click "Generate API Key", **copy the API key**. Command Code Login

Return to your terminal and paste the key, press Enter. You're authenticated. Command Code Login

## Next Steps Now you're ready to start coding with Command Code. - **[Quickstart](/command-code/quickstart)** - Get started with Command Code - **[Commands](/command-code/commands)** - CLI command reference - **[Command Code Studio](/command-code/studio)** - Visualize and manage your taste - **[Examples](/command-code/examples)** - See Command Code in action How Taste works https://commandcode.ai/docs/to-be-deleted/how-it-works/ import { generateMetadata } from '@/lib/generate-metadata'; import { TasteDemo } from '@/components/taste-demo'; # How Taste works Taste is a living model of your coding preferences. It watches your corrections and builds an invisible architecture of your choices. ## You Teach by Doing Once you start coding, Command Code will learn your preferences from your corrections. Every time you correct Command Code's output, it learns. Every time you state a preference, it remembers. Every time you refactor something, it notices the pattern. ```bash > I prefer bun instead of npm ``` Your preferences are saved in `.commandcode/taste/taste.md` so that next time you code, it will use bun instead of npm. ## The Neuro-Symbolic Engine Taste is a meta neuro-symbolic reasoning space with continuous reinforcement learning (RL). We combined reasoning with neural intuition to create an invisible architecture of choices. - **Continuously learning** side learns the texture of your code (explicit & implicit feedback) - **Meta Neuro-Symbolic space** enforces the invisible logic of your choices. - **Reflective Context Engineering** of a self-aware RL feedback loop to build skills. Neuro-Symbolic Formula

## How `taste.md` works When you enable taste learning, Command Code will create a `taste.md` file in your `.commandcode/taste/` directory. ```bash .commandcode/ └── taste/ ├── taste.md # Main taste profile ├── cli/ # CLI-specific learnings ├── typescript/ # TypeScript preferences └── architecture/ # Architecture patterns ``` ### 1. Learning from explicit preferences Tell Command Code what you prefer: ```bash > Please always use TypeScript for new files > I prefer functional components over class components > Use async/await instead of promises ``` Command Code remembers these preferences and applies them automatically. ### 2. Learning from corrections When you correct Command Code's output, it learns: ```bash > Actually, I prefer const over let > Can you use arrow functions instead? > This should be a functional component ``` Every correction teaches Command Code more about your preferences. ### 3. Confidence scores Taste rules have confidence scores betweet 0.0 to 1.0. This means: - One-off preferences don't become rules - Repeated patterns become stronger rules - Your taste profile gets better over time --- ## Next steps - Explore the [Taste Studio](/studio) to visualize your taste and manage your learnings. - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Features https://commandcode.ai/docs/to-be-deleted/features/ import { generateMetadata } from '@/lib/generate-metadata'; # Features Your coding agent should be as capable as you are. Here's what Command Code brings to your terminal. | Feature | Description | | --- | --- | | [Taste](/features/taste) | Stop repeating yourself. Command Code learns your patterns once. | | [Resume](/features/resume) | Pick up where you left off. No context lost between sessions. | | [Images](/features/images) | Drop a screenshot, get code. Vision-native debugging and generation. | | [@ Mentions](/features/mentions) | Reference any file, function, or symbol directly. Precision context. | | [Tools](/features/tools) | In built tools for Web Search. | | [Studio](/features/studio) | Visualize and manage your taste. See how Command Code is learning from your conversations. | ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Commands https://commandcode.ai/docs/to-be-deleted/commands/ import { generateMetadata } from '@/lib/generate-metadata'; # Commands This section contains a complete reference for all Command Code commands. --- ## CLI Commands Explore the CLI commands to start an interactive session or run a one-time task. - [`cmd`](/commands/cmd) - Start interactive session - [`cmd "task"`](/commands/cmd-task) - Run a one-time task - [`cmd auth login`](/commands/auth-login) - Authenticate - [`cmd auth logout`](/commands/auth-logout) - Log out --- ## Interactive Commands Available during chat sessions (type `/` followed by the command) - [`/init`](/commands/init) - Initialize AGENTS.md - [`/memory`](/commands/memory) - Manage project memory - [`/taste`](/commands/taste) - Manage taste learning - [`/resume`](/commands/resume) - Resume a past conversation - [`/clear`](/commands/clear) - Clear conversation history - [`/share`](/commands/share) - Share conversation - [`/unshare`](/commands/unshare) - Stop sharing - [`/agents`](/commands/agents) - Manage agents - [`/provider`](/commands/provider) - Select provider - [`/compact`](/commands/compact) - Compact conversation history - [`/help`](/commands/help) - Show commands - [`/exit`](/commands/exit) - Exit session --- ## Taste Commands Explore the taste commands to manage your taste learning. - [`npx taste push`](/commands/taste/push) - Push taste profile to Command Code registry - [`npx taste pull`](/commands/taste/pull) - Pull taste profile from Command Code registry - [`npx taste list`](/commands/taste/list) - List taste profiles - [`npx taste delete`](/commands/taste/delete) - Delete taste profile - [`npx taste lint`](/commands/taste/lint) - Lint taste profile - [`npx taste open`](/commands/taste/open) - Open taste profile in editor - [`npx taste help`](/commands/taste/help) - Show taste help `npx cmd taste` and `npx taste` are functionally the same, but we recommend using `npx taste`. --- ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Page https://commandcode.ai/docs/ import { generateMetadata } from '@/lib/generate-metadata'; import { Resources } from '@/components/Resources'; ![command-code](/docs/top.png) ### Commad Code is the first coding agent that continuously learns your *taste* of writing code. LLMs x Meta Neuro-Symbolic AI x Continuous Reinforcement Learning = Acquired Taste. --- ## Command Code: The Next Frontier in AI Coding

## Example ```bash > Build a CLI for generating UUIDs ``` ```ts > I always use commander, not yargs ``` From now on, Command Code will use commander to build the CLI. You'll see your taste profile growing in `.commandcode/taste/taste.md`. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Resume https://commandcode.ai/docs/to-be-deleted/features/resume/ import { generateMetadata } from '@/lib/generate-metadata'; # Resume This feature is for conversations that you want to continue from where you left off. It's like a time machine for your conversations with full context intact. --- ## Why it matters That complex refactoring you started yesterday. It's still in your conversation history. Resume lets you pick up any past session with full context intact so that you don't have to rebuild context. ## Quick Start ```ts /resume ``` Select the past session to resume and Command Code will pick up where you left off. Resume

## Examples ```ts cmd > /resume ``` ```md Recent sessions: > 1. 2d ago - Building auth middleware 2. 3d ago - Refactoring CLI to use commander ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Mentions https://commandcode.ai/docs/to-be-deleted/features/mentions/ import { generateMetadata } from '@/lib/generate-metadata'; # Mentions This feature is for referencing any files directly. Reference any file with @. The agent understands exactly what you mean and doesn't hallucinate paths. --- ## Why it matters You don't have to say "the auth file in the server directory," just reference it with `@server/auth.ts`. Mention any file in your project with `@`. ```ts > @server/auth.ts ```

Mention any file in your project with `@`

Command Code understands exactly what you mean and doesn't hallucinate paths. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Image https://commandcode.ai/docs/to-be-deleted/features/image/ import { generateMetadata } from '@/lib/generate-metadata'; # Image This feature is for debugging and generation. Drop screenshots, diagrams, mockups. Command Code's vision model reads them and acts. ## Why it matters Debugging a UI bug with screenshot and ask "why is this misaligned?" instead of describing it. Drag image into terminal: ```bash > [#Image1] Why is this button overflowing? ```

Command Code analyzes the screenshot, sees your Tailwind classes, and fixes it. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. cmd whoami https://commandcode.ai/docs/to-be-deleted/commands/whoami/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd whoami This command displays current user information for Command Code. ## Usage ```bash cmd whoami ``` This command displays current user information for Command Code. ## How It Works ```bash 1. Run `cmd whoami` 2. Terminal displays current user information ``` ```bash User Information: ℹ Name: [Your Name] ℹ Email: [Your Email] ℹ Username: [Your Username] ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. cmd update https://commandcode.ai/docs/to-be-deleted/commands/update/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd update This command updates Command Code to the latest version. ## Usage ```bash cmd update ``` This command updates Command Code to the latest version. ## How It Works ```bash 1. Run `cmd update` 2. Terminal updates Command Code to the latest version ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /unshare https://commandcode.ai/docs/to-be-deleted/commands/unshare/ import { generateMetadata } from '@/lib/generate-metadata'; # /unshare This command removes the public share link for the current conversation and makes it private again. --- ## Usage ```bash /unshare ``` This command removes the public share link for the current conversation and makes it private again. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/unshare` command and it will remove the public share link for the current conversation and make it private again 3. Command Code will show you a confirmation message ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. cmd status https://commandcode.ai/docs/to-be-deleted/commands/status/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd status This command displays authentication status for Command Code. ## Usage ```bash cmd status ``` This command displays authentication status for Command Code by checking if you are logged in. ## How It Works ```bash 1. Run `cmd status` 2. Terminal displays authentication status ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /resume https://commandcode.ai/docs/to-be-deleted/commands/resume/ # /resume This command resumes a past conversation with full context. --- ## Usage ```bash /resume ``` This command resumes a past conversation with full context. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/resume` command to resume a past conversation 3. Command Code will show you a numbered list of recent conversations 4. Select the conversation you want to resume by entering the number ``` Resume Command

### Project Memory Project memory is a persistent memory for the current project. It is stored in the `.AGENTS.md` file. ### User Memory User memory is a persistent memory for the current user. It is stored in the `~/.commandcode/AGENTS.md` file. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /share https://commandcode.ai/docs/to-be-deleted/commands/share/ import { generateMetadata } from '@/lib/generate-metadata'; # /share This command creates a public shareable link for your current conversation. --- ## Usage ```bash /share ``` This command creates a public shareable link for your current conversation. You see all the thinking, tool calls, messages and responses in the conversation. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/share` command and it will create a public shareable link for your current conversation 3. Command Code will show you the shareable link ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /init https://commandcode.ai/docs/to-be-deleted/commands/init/ import { generateMetadata } from '@/lib/generate-metadata'; # /init This command initializes the `AGENTS.md` file for the current project inside your Command Code session. ## Usage ```bash /init ``` This command initializes the `AGENTS.md` file in your project directory when you are inside the Command Code session. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/init` command 3. Command Code initializes the `AGENTS.md` file in your project directory ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. cmd auth login https://commandcode.ai/docs/to-be-deleted/commands/login/ # cmd auth login This command authenticates you with Command Code. ## Usage ```bash cmd auth login ``` This command authenticates you with Command Code. This is required before first use. The command will open your browser to the authentication page. ## How It Works ```bash 1. Run `cmd auth login` 2. Terminal asks: Would you like to sign in? (y/n) (y/n)` 3. Type `y` and hit Enter 4. Terminal asks: Open the authentication page? (y/n) 5. Select `Yes/No` in the terminal and press Enter 6. Your browser opens to the authentication page 7. Click Generate API Key and copy the API key 8. Paste the API key back in the terminal 9. Done! You'll see: `✓ Authenticated` ``` ## Troubleshooting If you get an error message, try running theses commands in the terminal: ```bash cmd auth logout ``` ```bash cmd auth login ``` If you still get an error message, please reach out to us on our [Discord community](https://langbase.com/discord). ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. cmd auth logout https://commandcode.ai/docs/to-be-deleted/commands/logout/ # cmd auth logout This command logs you out of Command Code and removes your stored API key from local storage. ## Usage ```bash cmd auth logout ``` This command logs you out of Command Code and removes your stored API key from local storage. This is useful when switching accounts or removing credentials from a shared machine. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /exit https://commandcode.ai/docs/to-be-deleted/commands/exit/ import { generateMetadata } from '@/lib/generate-metadata'; # /exit This command exits the Command Code session. --- ## Usage ```bash /exit ``` This command exits the Command Code session. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/exit` command 3. Command Code will exit the session ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /help https://commandcode.ai/docs/to-be-deleted/commands/help/ import { generateMetadata } from '@/lib/generate-metadata'; # /help This command shows all available interactive commands. --- ## Usage ```bash /help ``` This command shows all available interactive commands. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/help` command 3. Command Code will show you the list of available interactive commands ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. cmd config https://commandcode.ai/docs/to-be-deleted/commands/config/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd config This command manages CLI configuration for Command Code. ## Usage ```bash cmd config ``` The `config` command allows you to view, set, get, and reset configuration values for Command Code. ## Commands ### List all configuration values View all currently set configuration values: ```bash cmd config list ``` ### Get a configuration value Retrieve the value of a specific configuration key: ```bash cmd config get ``` ### Set a configuration value Set or update a configuration value: ```bash cmd config set ``` ### Reset all configuration Clear all configuration values and restore defaults: ```bash cmd config reset ``` This will remove all your custom configuration settings. ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. cmd https://commandcode.ai/docs/to-be-deleted/commands/cmd/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd This command starts an interactive Command Code session in your current directory. --- ## Usage ```bash cmd ``` This command starts an interactive Command Code session with your project's context already loaded. ## Available Flags To see all available flags for the `cmd` command, use: ```bash cmd --help ``` ## Flags - ### `--version` or `-V` This flag outputs the version number for Command Code. ```bash cmd --version # or cmd -V ``` - ### `--resume` or `-r` This flag resumes a list of recent conversations and lets you resume any session with full context. ```bash cmd --resume ``` - ### `--continue` or `-c` This flag continues the last conversation with full context preserved. ```bash cmd --continue ``` - ### `--trust` or `-T` This flag auto-trusts the project by skipping the initial permission prompt. ```bash cmd --trust ``` - ### `--taste-learn` This flag enables taste learning for this session. ```bash cmd --taste-learn ``` - ### `--crud` This flag enables all CRUD permissions for the session. ```bash cmd --crud ``` - ### `--cru` This flag enables Create, Read, and Update permissions (no Delete). ```bash cmd --cru ``` - ### `--create` This flag enables Create permission only. ```bash cmd --create ``` - ### `--read` This flag enables Read permission only. ```bash cmd --read ``` - ### `--update` This flag enables Update permission only. ```bash cmd --update ``` - ### `--delete` This flag enables Delete permission only. ```bash cmd --delete ``` - ### `--help` or `-h` This flag displays help for the command. ```bash cmd --help ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /compact https://commandcode.ai/docs/to-be-deleted/commands/compact/ import { generateMetadata } from '@/lib/generate-metadata'; # /compact This command summarizes conversation history to preserve context while saving tokens. ## Usage ```bash /compact ``` This command summarizes conversation history to preserve context while saving tokens. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/compact` command 3. Command Code will summarize the conversation history and preserve the context ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /agents https://commandcode.ai/docs/to-be-deleted/commands/agents/ import { generateMetadata } from '@/lib/generate-metadata'; # /agents This command creates, edits, and manages specialized agents for specific tasks. --- ## Usage ```bash /agents ``` This command creates, edits, and manages specialized agents for specific tasks. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/agents` command 3. Command Code will open the agent management menu 4. You can create, edit, list, and switch between specialized agents 5. Agents are customized versions of Command Code with specific system prompts and behaviors for different tasks ``` Agents Command

### **You will able to see the following options:** 1. **Project** - Create a new agent for the current project - Describe the agent you want, and Command Code will create it. - This agent will be saved in the current project 2. **Personal** - Create a new agent for your personal use - Saved in your personal account - You can use this agent in any project you want

## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. cmd info https://commandcode.ai/docs/to-be-deleted/commands/info/ import { generateMetadata } from '@/lib/generate-metadata'; # cmd info This command displays system information for Command Code. ## Usage ```bash cmd info ``` This command displays system information for Command Code. ## How It Works ```bash 1. Run `cmd info` 2. Terminal displays system information ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. /clear https://commandcode.ai/docs/to-be-deleted/commands/clear/ import { generateMetadata } from '@/lib/generate-metadata'; # /clear This command clears the conversation history and starts a fresh session. --- ## Usage ```bash /clear ``` This command clears the conversation history and starts a fresh session. ## How It Works ```bash 1. Be inside the Command Code session 2. Run `/clear` command to clear the conversation history 3. Command Code will clear the conversation history and start a fresh session ``` ## Next Steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Common workflows https://commandcode.ai/docs/workflows/ import { generateMetadata } from '@/lib/generate-metadata'; # Common workflows Each task in this document includes clear instructions, example commands, and best practices to help you get the most from Command Code. --- ## Understand new codebases You can quickly get a high-level overview of a codebase by navigating to the project root directory and starting Command Code. ```bash cd /path/to/project ``` ```bash cmd ``` ``` > give me brief overview of this codebase ``` ``` > explain the architecture patterns used in this codebase ``` ``` > how is payment system implemented in this codebase? ``` --- ## Tell your taste preferences You can tell Command Code your taste preferences to start building your profile while you code. Here are some examples of taste preferences you can tell Command Code related to your projects: ```bash > I always use pnpm instead of npm > I use TypeScript for CLI projects > I use tsup as build tool > I use commandar for CLI commands ``` You can use your taste profiles from anywhere by pushing them to the [Command Code Studio](https://commandcode.ai). ```bash npx taste push ``` Use `npx taste` commands to manage taste remotely. --- ## Resume previous conversations Suppose you've been working on a task with Command Code and need to continue where you left off in a later session. Command Code provides two options for resuming previous conversations: - `--continue` to automatically continue the most recent conversation - `--resume` to display a conversation picker ```bash cmd --continue ``` This immediately resumes your most recent conversation without any prompts. ```bash cmd --resume ``` This displays an interactive conversation selector with a clean list view showing: - Session summary (or initial prompt) - Metadata: time elapsed, message count, and git branch Use arrow keys to navigate and press Enter to select a conversation. Press Esc to exit. ```bash Modified # Messages Git Branch Summary ❯ 1. 20 hours ago 172 main Follow this practice and up... 2. 21 hours ago 13 main Add the common worflows her... 3. 22 hours ago 2 main does this {src/components/u... 4. 22 hours ago 82 main pnpm dlx shadcn@latest add ... 5. 1 day ago 2 ankit/features all tools support you have 6. 2 days ago 20 ankit/commands Update the content in each ... 7. 3 days ago 28 main For each command make a fol... 8. 6 days ago 11 main Why Command Code similar to... ``` --- ## Find relevant code Suppose you need to locate code related to a specific feature or functionality. ``` > find the files that handle authentication logic ``` ``` > how do these files handle authentication logic? ``` ``` > explain the authentication flow from front-end to database ``` --- ## Fix bugs efficiently Suppose you've encountered an error message and need to find and fix its source. ``` > I'm seeing an build error when I run `npm run build`. ``` ``` > I prefer to run `pnpm run build` after the change to see the build error ``` ``` > suggest a few ways to fix the bugs in @user.ts ``` ``` > update @user.ts to fix the bugs ``` --- ## Refactor code Suppose you need to update old code to use modern patterns and practices. ``` > find deprecated API endpoints in this codebase ``` ``` > suggest how to refactor @auth.ts to use OAuth2 authentication ``` ``` > refactor @auth.ts to use OAuth2 authentication ``` ``` > run tests for the refactored code ``` --- ## Write tests for your code Suppose you need to add tests for uncovered code. ``` > find functions and files in which are not covered by tests ``` ``` > I prefer to use Vitest for testing > I use __test__ prefix for test files ``` ``` > add tests for those functions and files ``` ``` > add test cases for edge conditions in those functions and files ``` ``` > run the new tests and fix any failures ``` --- ## Create pull requests Suppose you need to create a well-documented pull request for your changes. ``` > summarize the changes I've made to the authentication logic ``` ``` > create a pr for those changes ``` ``` > add information about the changes I've made to the PR description ``` --- ## Handle documentation Suppose you need to add or update documentation for your code. ``` > find functions without proper documentation in this codebase ``` ``` > add documentation for those functions in this codebase ``` ``` > improve the documentation with your review and suggestions ``` ``` > check if the documentation follows our project standards ``` --- ## Work with images It supports images in the conversation. You can use images to debug UI bugs, describe UI elements, and check for issues in diagrams. You can copy paste an image into the CLI or reference an image file in the conversation. ``` > Copy an image and paste it into the CLI ``` ``` > Reference an image file in the conversation ``` ``` > What are the UI elements used in this image describe them [#Image#1] ``` ``` > Genreate the CSS to match the same design shown in the image [#Image#1] ``` ``` > Analyze this diagram and suggest improvements [#Image#1] ``` ``` > Debug this UI bug with the image [#Image#1] ``` ``` > Analyze this schema and suggest modifications for the new feature [#Image#1] ``` --- ## Reference files and directories Use @ to quickly include files or directories in the conversation. ``` > Explain the logic in this file @auth.ts ``` The will help Command Code to understand the context of the file and provide better suggestions. ``` > Look at this directory @src/app and explain the structure? ``` This provides a directory listing with file information and explains the structure of the directory. --- ## Run parallel Command Code sessions with Git worktrees You can use Git worktrees to work on multiple tasks simultaneously using your taste preferences without giving lot of context again and again to ship code faster. Git worktrees allow you to check out multiple branches from the same repository into separate directories. Each worktree has its own working directory with isolated files, while sharing the same Git history. You can learn more about Git worktrees in the [official Git worktree documentation](https://git-scm.com/docs/git-worktree). ```bash git worktree add ../project-feature-auth -b feature-auth ``` ```bash git worktree add ../project-auth auth-bugfix ``` This creates a new directory with a separate working copy of your repository. ```bash cd ../project-feature-auth ``` ```bash cmd ``` ```bash cd ../project-auth-bugfix ``` ```bash cmd ``` ```bash git worktree list ``` ```bash git worktree remove ../project-auth-bugfix ``` --- ## Ask Command Code about its capabilities Command Code has built-in access to its documentation and can answer questions about its own features and limitations. ### Example questions ``` > can you help me to create a pull requests? ``` ``` > What tools are available to you? ``` --- Command Code Enterprise https://commandcode.ai/docs/enterprise/ import { generateMetadata } from '@/lib/generate-metadata'; # Command Code Enterprise Command Code offers an Enterprise edition designed for organizations that require enhanced security, compliance, and control over their development environment. If you want to ensure that your code and data never leaves your infrastructure, Command Code Enterprise is the solution for you. To get started with Command Code Enterprise: Reach out to our sales team at support@langbase.com. Taste https://commandcode.ai/docs/taste/ import { generateMetadata } from '@/lib/generate-metadata'; # Taste Taste is our meta neuro-symbolic AI model with continuous reinforcement learning (RL). We combine reasoning with neural intuition to create an invisible architecture of choices, we call taste. --- ## Taste: The Next Frontier in AI Coding

--- ## `taste-1` Introducing 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 choices, we call taste. ![meta neuro-symbolic ai model taste-1](/docs/mns.png) - **Continuously learning** side learns the texture of your code (explicit & implicit feedback). - **Meta Neuro-Symbolic AI model `taste-1`** enforces your 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. --- ## How to get started You can install Command Code by following these steps: **Step 1: Install Command Code** ```bash {{ title: 'npm' }} npm i -g command-code ``` ```bash {{ title: 'pnpm' }} pnpm i -g command-code ``` ```bash {{ title: 'yarn' }} yarn global add command-code ``` **Step 2: Login to Command Code** ```bash cmd login ``` **Step 3: Start coding with Command Code** ```bash cmd ``` 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. ## Taste Sharing and Portability The architecture of Taste is fundamentally built around the principle that taste should be transferable and composable. Your learned preferences should be trapped in a single project you can use them in other projects. ## Managing Taste with `npx taste` We've made sharing and managing taste profiles as simple as using Git. The `npx taste` CLI tool is your primary interface for pulling, pushing, and composing taste models which you can view in the [Command Code Studio](/studio/taste). ``` npx taste push --all ``` This will push your taste to the Command Code Studio. ``` npx taste pull ``` This will pull your taste from the Command Code Studio. Use [`npx taste` commands](/reference/cli#taste-commands) to manage taste remotely. --- ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://commandcode.ai/discord) for feedback, requests, and support. Quickstart: Command Code https://commandcode.ai/docs/quickstart/ import { generateMetadata } from '@/lib/generate-metadata'; # Quickstart: Command Code Welcome to Command Code! --- In this quickstart guide, we'll walk you through the steps to get up and running with Command Code, the AI-powered coding agent that learns your taste of coding style and preferences using both LLMs and continuous learning with meta neuro-symbolic model taste-1 Use your preferred package manager: ```sh {{ title: 'npm' }} npm i -g command-code ``` ```sh {{ title: 'pnpm' }} pnpm i -g command-code ``` ```sh {{ title: 'yarn' }} yarn global add command-code ``` Login with CommandCode.ai: Command Code is available globally as `command-code` or shorter alias `cmd` CLI. ```bash cmd login ``` 1. Run `cmd login` 2. Open auth page in browser (sign up or log in) 3. Generate your API key 4. Paste key in terminal 5. Select Provider: `Command Code` ``` ┌ Command Code Authentication │ ◇ Open the authentication page? — copy your API key and paste it here. │ Yes │ ◇ Copy/Paste your API key in the terminal: │ ************************************* │ ◇ Select provider │ Command Code (recommended) │ └ You are logged in. API key is stored in ~/.commandcode/auth.json file. ``` Now you're logged in. Let's try it out! Navigate to any project directory and start Command Code `cmd`: ```sh cd your-project ``` ```sh cmd ``` You can start by providing a prompt like this: ```md Build a date.js CLI with that tells ISO format of date. Use commander.js and pnpm. ``` You'll see that in your projects `.commancode/taste/taste.md` files and folders where `cmd` has started learning your coding taste. In the taste.md file, Command Code will have learned something like this: ```md # CLI - Use pnpm as package manager. Confidence: 0.50 - Use commander.js for CLI argument parsing. Confidence: 0.50 ``` Command Code will continuously learn your taste, and auto manage the taste files and folders. As your taste grows, you'll see Command Code taking your taste out of the main taste.md file into separate files and folders for better organization and reflective context engineering. Meaning only relevant taste context will be used for your coding sessions. For example, if you are working on a React component, only React-related taste context will be used. - You can press `Shift + Tab` to switch auto `accept edits on`. - You can press `Ctrl + C` to exit anytime. Please join our [Discord community](https://langbase.fyi/discordcmd) to share your feedback and get help. We're still in early days and figuring out the best interface for taste. Taste.md files and folders in your projects allow you full git versioning control. We also have a lot more meta learning on roadmap, help us shape it! --- ## Essential commands Here are the commands you'll use most: | Command | What it does | |---------|-------------| | `cmd` | Start interactive mode | | `/taste` | Toggle taste learning on/off | | `/share` | Create a shareable link for the thread | | `/unshare` | Stop sharing the thread | | `/resume` | Resume a past thread | | `/memory` | Manage project memory (persistent context) | | `/provider` | Select AI provider (currently support Command Code only) | | `/clear` | Clear the thread history | | `/help` | Show all available commands | --- npx taste push https://commandcode.ai/docs/to-be-deleted/commands/taste/push/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste push This command pushes a taste profile to the Command Code registry. --- ## Usage ``` npx taste push [package] ``` This command pushes a taste profile to the Command Code registry. If no package is specified, it will push the current package. ## Options - `-g, --global` - Push to global storage - `--remote` - Push to remote registry - `--all` - Push all packages - `--overwrite` - Overwrite target without prompting (default: interactive merge) ## How It Works ```bash 1. Command Code will push the taste profile to the Command Code Studio 2. View your taste profile in the Command Code Studio ``` ## Example ```bash {title: Push current package} npx taste push cli -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. npx taste pull https://commandcode.ai/docs/to-be-deleted/commands/taste/pull/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste pull This command pulls a taste profile from the Command Code registry. --- ## Usage ``` npx taste pull [package] ``` This command pulls a taste profile from the Command Code registry. If no package is specified, it will pull the current package. ## Options - `-g, --global` - Pull from global storage - `--remote` - Pull from remote registry - `--all` - Pull all packages - `--overwrite` - Overwrite local without prompting (default: interactive merge) ## How It Works ```bash 1. Command Code will pull the taste profile from the Command Code Studio 2. Merge or overwrite local taste profile based on your selection ``` ## Example ```bash {title: Pull current package} npx taste pull cli -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. npx taste open https://commandcode.ai/docs/to-be-deleted/commands/taste/open/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste open This command opens a taste package in your editor. --- ## Usage ``` npx taste open ``` This command opens a taste package in your default editor for viewing or editing. ## Options - `-g, --global` - Open from global storage ## How It Works ```bash 1. Command Code will locate the package in local or global storage 2. Open the package files in your default editor ``` ## Example ```bash {title: Open global package} npx taste open cli -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. npx taste list https://commandcode.ai/docs/to-be-deleted/commands/taste/list/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste list This command lists available taste packages. --- ## Usage ``` npx taste list ``` This command lists available taste packages from local, global, or remote storage. ## Options - `-g, --global` - List global packages - `--remote` - List remote packages ## How It Works ```bash 1. Command Code will fetch available packages from the specified source 2. Display packages with their details and preferences count ``` ## Example ```bash {title: List global packages} npx taste list -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. npx taste help https://commandcode.ai/docs/to-be-deleted/commands/taste/help/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste help This command displays help information for taste commands. --- ## Usage ``` npx taste help ``` This command displays help information for the taste CLI and its commands. If a command is specified, it shows detailed help for that command. ## Options - `-h, --help` - Display help for command - `-v, --version` - Output the version number ## Available Commands - `push [options] [package]` - Push packages from project to remote or global storage - `pull [options] [package]` - Pull packages from storage to project - `list [options]` - List available packages - `delete [options] ` - Delete a package - `lint [options] [package]` - Validate taste file format and structure - `open [options] ` - Open a package in your editor - `update` - Update taste CLI to the latest version - `help [command]` - Display help for command ## How It Works ```bash 1. Command Code will display the main help menu with all available commands 2. If a command is specified, show detailed help for that specific command ``` ## Example ```bash {title: Help for specific command} npx taste help push ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. npx taste lint https://commandcode.ai/docs/to-be-deleted/commands/taste/lint/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste lint This command validates taste file format and structure. --- ## Usage ``` npx taste lint [package] ``` This command validates the format and structure of taste files. If no package is specified, it will lint the current package. ## Options - `-g, --global` - Lint global packages - `--all` - Lint all packages ## How It Works ```bash 1. Command Code will check the taste file format and structure 2. Report any validation errors or warnings ``` ## Example ```bash {title: Lint all packages} npx taste lint --all -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. npx taste delete https://commandcode.ai/docs/to-be-deleted/commands/taste/delete/ import { generateMetadata } from '@/lib/generate-metadata'; # npx taste delete This command deletes a taste package. --- ## Usage ``` npx taste delete [package] ``` This command deletes a taste package from local or global storage. ## Options - `-g, --global` - Delete from global storage ## How It Works ```bash 1. Command Code will locate the package in local or global storage 2. Remove the package and all its associated files ``` ## Example ```bash {title: Delete global package} npx taste delete cli -g ``` ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. Usage https://commandcode.ai/docs/studio/usage/ import { generateMetadata } from '@/lib/generate-metadata'; # Usage Track your usage for every single request you make in Command Code. --- Navigate to the Usage tab in the Studio to see your usage. This shows you the total cost, and the total number of tokens used for each request. Usage

Click on a request to see the usage details. This shows you the each request's usage, the total cost, and the total number of tokens used.

Teams https://commandcode.ai/docs/studio/teams/ import { generateMetadata } from '@/lib/generate-metadata'; # Teams Teams are used to manage your team members and their permissions in Command Code. Taste Studio https://commandcode.ai/docs/studio/taste/ import { generateMetadata } from '@/lib/generate-metadata'; # Taste Studio Taste Studio is used to manage your taste preferences. You can manage them via `npx taste` commands. --- You can use Taste Studio to: - **View Taste Profile**: See your taste categories (cli, react, typescript) - **Push taste profiles**: Use `npx taste push` to push taste to studio - **Pull taste profiles**: Use `npx taste pull` to pull taste from studio - **Team management**: Invite org members to share @teammate-username/taste You can push a taste profile to the Command Code Studio to share it with your team.

```bash npx taste push ``` Navigate to the Taste tab in the Studio to see all your taste profiles. Taste Studio

You can pull a taste profile from the Command Code Studio to your different projects. Install the taste profile

```bash npx taste pull ``` Click on a taste profile to explore it. This shows you the taste profile's details, the `taste.md` file, and the confidence scores. Taste Studio

API Keys https://commandcode.ai/docs/studio/api-keys/ import { generateMetadata } from '@/lib/generate-metadata'; # API Keys API Keys are used to authenticate you for using Command Code. --- ## How to get your API key You can get your API key by following these steps: Login to your account on [Command Code](https://commandcode.com/). Navigate to your [API keys page](https://studio.commandcode.com/api-keys). Command Code API keys

Click on the `Generate API key` button to generate a new API key. Command Code API keys

From here you can manage your existing API keys. Command Code API keys

Interactive Mode https://commandcode.ai/docs/reference/interactive/ import { generateMetadata } from '@/lib/generate-metadata'; # Interactive Mode This page provides a complete reference for the Command Code's interactive mode. --- ## Slash Commands List of the main interactive slash commands and their descriptions. | **Slash Commands** | **Description** | **Example** | | ------------------ | ---------------------------- | ----------- | | `/init` | Initialize `AGENTS.md` | `/init` | | `/memory` | Manage project memory | `/memory` | | `/resume` | Resume a past conversation | `/resume` | | `/share` | Share conversation | `/share` | | `/unshare` | Stop sharing | `/unshare` | | `/taste` | Manage taste learning | `/taste` | | `/model` | Switch between Command Code models | `/model` | | `/clear` | Clear conversation history | `/clear` | | `/agents` | Manage agents | `/agents` | | `/compact` | Compact conversation history | `/compact` | | `/help` | Show commands | `/help` | | `/exit` | Exit session | `/exit` | ## Quick Commands List of the shortcuts that are available during interactive sessions: | **Shortcut** | **Description** | **Notes** | | ------------ | ----------------- | ------------------------------------------------------------- | | `/` at start | Slash command | See [slash commands](/reference/interactive#slash-commands) | | `!` at start | Bash mode | Run commands directly and add execution output to the session | | `@` | File path mention | Trigger file path autocomplete | CLI Reference https://commandcode.ai/docs/reference/cli/ import { generateMetadata } from '@/lib/generate-metadata'; # CLI Reference This page provides a complete reference for all the CLI and taste commands. --- ## CLI Commands List of the main CLI commands and their description. | **Command** | **Description** | **Example** | | ----------- | ----------------------------------------- | ------------------------------ | | `cmd` | Start an interactive session | `cmd` | | `login` | Authenticate your account access | `cmd login` | | `taste` | Manage taste learning packages | `cmd taste push` | | `config` | Manage CLI configuration | `cmd config set ` | | `logout` | Log out from your account | `cmd logout` | | `whoami` | Display current user information | `cmd whoami` | | `update` | Update Command Code to the latest version | `cmd update` | ## Taste Commands List of the all taste commands and their description. | **Command** | **Description** | **Example** | | ------------------ | --------------------------------------------- | ------------------ | | `npx taste push` | Push taste profile to Command Code registry | `npx taste push` | | `npx taste pull` | Pull taste profile from Command Code registry | `npx taste pull` | | `npx taste list` | List taste profiles | `npx taste list` | | `npx taste delete` | Delete taste profile | `npx taste delete` | | `npx taste lint` | Lint taste profile | `npx taste lint` | | `npx taste open` | Open taste profile in editor | `npx taste open` | | `npx taste help` | Show taste help | `npx taste help` | `npx cmd taste` and `npx taste` are functionally the same, but we recommend using `npx taste`. --- ## CLI Flags You can customise Command Code's CLI behaviour with the following flags. | **Flag** | **Description** | **Example** | | -------------------- | --------------------------------------------------- | ------------------- | | `-v, --version` | Output the version number | `cmd --version` | | `-r, --resume` | Resume a conversation | `cmd --resume` | | `-c, --continue` | Continue the last conversation | `cmd --continue` | | `-t, --trust` | Auto-trust project (skip initial permission prompt) | `cmd --trust` | | `-tL, --taste-learn` | Enable taste learning | `cmd --taste-learn` | | `-crud, --crud` | Enable all CRUD permissions | `cmd --crud` | | `-cru, --cru` | Enable Create, Read, Update (no Delete) | `cmd --cru` | | `-c, --create` | Enable Create permission | `cmd --create` | | `-r, --read` | Enable Read permission | `cmd --read` | | `-u, --update` | Enable Update permission | `cmd --update` | | `-d, --delete` | Enable Delete permission | `cmd --delete` | | `-h, --help` | Display help for Command Code | `cmd --help` | --- ## Next steps - Build something cool with Command Code and see your taste in action - Join our [Discord community](https://langbase.com/discord) for feedback, requests, and support. What is Taste? https://commandcode.ai/docs/taste/what-is-taste/ import { generateMetadata } from '@/lib/generate-metadata'; # What is Taste? We have built our first meta neuro-symbolic AI model `taste-1` with continuous reinforcement learning (RL). We combine reasoning with neural intuition to create an invisible architecture of choices. --- `taste-1` Introducing 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 choices, we call taste. ![meta neuro-symbolic ai model taste-1](/docs/mns.png) - **Continuously learning** side learns the texture of your code (explicit & implicit feedback). - **Meta Neuro-Symbolic AI model `taste-1`** enforces your the invisible logic of your choices. - **Reflective Context Engineering** of a self-aware RL feedback loop to build skills. Manage Taste https://commandcode.ai/docs/taste/manage/ import { generateMetadata } from '@/lib/generate-metadata'; # Manage Taste Taste sharing and managing taste profiles is as simple as using Git via the `npx taste` CLI. --- ## How to get started You can install Command Code by following these steps: **Step 1: Install Command Code** ```bash {{ title: 'npm' }} npm i -g command-code ``` ```bash {{ title: 'pnpm' }} pnpm i -g command-code ``` ```bash {{ title: 'yarn' }} yarn global add command-code ``` **Step 2: Login to Command Code** ```bash cmd login ``` **Step 3: Start coding with Command Code** ```bash cmd ``` This unified interface lets you push your learned preferences to the [Command Code Studio](/studio/taste), pull taste from teammates or the community, and compose multiple taste profiles to match your workflow. You can push your taste to the Command Code Studio and share it with your team. ```bash npx taste push --all ``` You can pull a taste profile from the Command Code Studio to your different projects. ```bash npx taste pull ``` You can list all the taste profiles available in the Command Code Studio. ```bash npx taste list ``` You can open a specific taste profile in Command Code Studio. ```bash npx taste open ``` You can delete a specific taste profile from the Command Code Studio. ```bash npx taste delete ``` Learn more about the [`npx taste` commands](/reference/cli#taste-commands) to manage taste profiles remotely. Pricing Limits https://commandcode.ai/docs/resources/pricing-limits/ import { generateMetadata } from '@/lib/generate-metadata'; # Pricing Limits Clear, honest pricing. No tricks. --- ## Individual Plans | Plan | Monthly Price | Monthly limits | |------|---------------|------------------| | Free | $10 (one-time) | Capacity based | | Pro | $15 | ~250 Premium Requests | | Max | $200 | ~3,500 Premium Requests | ## Team Plans | Plan | Monthly Price | Monthly limits | |------|---------------|------------------| | Team Pro | $40 | ~350 Premium Requests | | Team Max | $400 | ~3,500 Premium Requests | | Enterprise | $5,000+ | Unlimited // custom terms | **How it works:** - Monthly requests limits reset each month. - Auto top-up and buy extra credits at model cost. They roll over and never expire. - Enterprise plans? Email support@langbase.com for custom terms, SLAs, and dedicated support. Legal https://commandcode.ai/docs/resources/legal/ import { generateMetadata } from '@/lib/generate-metadata'; # Legal Command Code doesn't train on your code or store your code snippets. `TASTE` runs on your codebase and stores learning data in your project and on your local machine only. More details can be found in our [Privacy Policy](https://langbase.com/privacy) and [Terms of Service](https://langbase.com/terms). --- FAQs https://commandcode.ai/docs/resources/faqs/ import { generateMetadata } from '@/lib/generate-metadata'; import { Faq } from '@/components/Faq'; import Link from 'next/link'; # FAQs Frequently asked questions about Command Code. --- Command Code offers both free and premium plans. Check our{' '} pricing page {' '} for more details.

) }, { question: 'How do I install Command Code?', answer: (

See our quickstart guide for installation instructions.

) }, { question: 'What is the difference between Command Code and Langbase?', answer: (

Command Code is built by Langbase and shares the same core mission.

) } ]} /> Providers https://commandcode.ai/docs/configuration/providers/ import { generateMetadata } from '@/lib/generate-metadata'; # Providers Command Code providers.