Customizing CodeBuddy: Rules, Memories, Skills and MCP

Why customization matters

A default AI assistant knows general programming but knows nothing about your project. Customization is essentially feeding it your project knowledge once, so you stop re-explaining the same things in every conversation. CodeBuddy offers a full set of entry points, from soft preferences to hard rules.

Rules: write your coding standards into the environment

Rules live in the .codebuddy/rules directory and take effect as mandatory constraints. They suit content like directory and file naming conventions, the state management approach, the request wrapper you must use, dependencies that are off-limits, and pre-commit checks.

They are far more reliable than reminding the assistant in every conversation, because rules persist and don't depend on whether you remember to say it.

Memories: remember your preferences

Memories capture habitual preferences such as response language, comment style, preferred patterns, and your usual stack. They act as soft constraints and build up as you work. The pairing is straightforward: hard standards go in Rules, soft preferences go in Memories, and the two shouldn't be mixed.

Skills: package specialized workflows as capabilities

Skills live under .codebuddy/skills/. When a class of task always follows the same steps, such as creating a page from the team template, generating API docs to spec, or running a pre-release checklist, write it as a Skill and invoke it in one sentence instead of restating the process. The test is simple: if you've described the workflow more than three times, it's time to package it.

MCP: connect third-party tools

MCP lets CodeBuddy call external tools and data sources, such as querying a database, reading API docs, or operating a project management tool. It extends the assistant from "only sees code files" to "can reach real systems." Before connecting anything, clarify the permission scope: what it can do depends on what access you grant, so don't start with write permissions.

Custom models, commands, and agents

• Custom models: connect your own model through an API.
• Custom commands: turn high-frequency instructions into short commands.
• Custom agents: configure dedicated behavior and prompts for a specific role.
• Hooks and the plugin marketplace: insert automation at key moments, or reuse extensions others have already built.

Rolling it out across a team

1. Start with Rules. It's the cheapest step with the most direct payoff, so nail down naming, directories, and dependencies first.
2. Then turn your two or three most frequent workflows into Skills. Don't roll out ten at once.
3. Add MCP as needed, read-only first, writes later.
4. Review regularly: any prompt you keep reusing should become a rule or a skill.

Start small

Don't build the whole system on day one. Solve one real pain point first, such as "every new page starts with copy-pasting a pile of boilerplate," turn it into a Skill, and add the next one once it runs smoothly. A system grows; it isn't designed up front. For a structured learning path, visit the learning center; for tool comparisons, the tool library. This article reflects the state as of 2026-11; directory structure and capabilities follow the official documentation.