save-learning
The save-learning skill detects when users state preferences, rules, or instructions they want applied across future sessions, such as "remember this" or "always do X." It refines these statements into actionable learnings with appropriate type prefixes like convention or preference, confirms them with the user, then persists them using the caliber learn command so they apply to all future project work. Use when users explicitly request something be remembered or proactively suggest when they state clear preferences or project conventions.
git clone --depth 1 https://github.com/caliber-ai-org/ai-setup /tmp/save-learning && cp -r /tmp/save-learning/skills/save-learning ~/.claude/skills/save-learningSKILL.md
# Save Learning
Save a user's instruction or preference as a persistent learning that
will be applied in all future sessions on this project.
## Instructions
1. Detect when the user gives an instruction to remember, such as:
- "remember this", "save this", "always do X", "never do Y"
- "from now on", "going forward", "in this project we..."
- Any stated convention, preference, or rule
2. Refine the instruction into a clean, actionable learning bullet with
an appropriate type prefix:
- `**[convention]**` — coding style, workflow, git conventions
- `**[pattern]**` — reusable code patterns
- `**[anti-pattern]**` — things to avoid
- `**[preference]**` — personal/team preferences
- `**[context]**` — project-specific context
3. Show the refined learning to the user and ask for confirmation
4. If confirmed, run:
```bash
caliber learn add "<refined learning>"
```
For personal preferences (not project-level), add `--personal`:
```bash
caliber learn add --personal "<refined learning>"
```
5. Stage the learnings file for the next commit:
```bash
git add CALIBER_LEARNINGS.md
```
## Examples
User: "when developing features, push to next branch not master, remember it"
-> Refine: `**[convention]** Push feature commits to the \`next\` branch, not \`master\``
-> "I'll save this as a project learning:
**[convention]** Push feature commits to the \`next\` branch, not \`master\`
Save for future sessions?"
-> If yes: run `caliber learn add "**[convention]** Push feature commits to the next branch, not master"`
-> Run `git add CALIBER_LEARNINGS.md`
User: "always use bun instead of npm"
-> Refine: `**[preference]** Use \`bun\` instead of \`npm\` for package management`
-> Confirm and save
User: "never use any in TypeScript, use unknown instead"
-> Refine: `**[convention]** Use \`unknown\` instead of \`any\` in TypeScript`
-> Confirm and save
## When NOT to trigger
- The user is giving a one-time instruction for the current task only
- The instruction is too vague to be actionable
- The user explicitly says "just for now" or "only this time"Creates a new CLI command following the Commander.js pattern in src/commands/. Handles command registration in src/cli.ts, telemetry tracking via tracked() wrapper, and option parsing. Use when user says add command, new CLI command, create subcommand, or adds files to src/commands/. Do NOT use for modifying existing commands or fixing bugs in existing commands.
Writes Vitest tests following project patterns: __tests__/ directories, vi.mock() for module mocking with vi.hoisted() for test-time factories, global LLM mock from src/test/setup.ts, environment variable save/restore in beforeEach/afterEach, vi.clearAllMocks() lifecycle, and test file organization. Use when user says 'write tests', 'add test coverage', 'test this', creates *.test.ts files, or when test failures appear in CI. Do NOT use for non-test code or for debugging without writing tests.
Discovers and installs community skills from the public registry. Use when the user mentions a technology, framework, or task that could benefit from specialized skills not yet installed, asks 'how do I do X', 'find a skill for X', or starts work in a new technology area. Proactively suggest when the user's task involves tools or frameworks without existing skills.
Adds a new LLM provider implementing LLMProvider interface with call() and stream() methods. Integrates with provider factory in src/llm/index.ts, config detection in src/llm/config.ts, and error handling via tracking and recovery. Use when adding a new model backend, integrating a third-party LLM API, or extending LLM platform support. Do NOT use for fixing bugs in existing providers, modifying existing provider behavior, or changing the LLMProvider interface.
Add a new deterministic scoring check in src/scoring/checks/ that evaluates config quality. Follows the Check[] return pattern, uses point constants from src/scoring/constants.ts, and integrates via filterChecksForTarget() in src/scoring/index.ts. Use when user says 'add scoring check', 'new check', 'modify scoring criteria', or works in src/scoring/checks/. Do NOT use for display changes or refactoring scoring logic.
Sets up Caliber for automatic AI agent context sync. Installs pre-commit hooks so CLAUDE.md, Cursor rules, and Copilot instructions update automatically on every commit. Use when Caliber hooks are not yet installed or when the user asks about keeping agent configs in sync.
Add a new platform writer module in src/writers/ that generates and writes agent config files for a supported platform. Each writer exports a function that accepts a config interface, creates directories (rules/, skills/, mcp configs), writes files with proper formatting and frontmatter, and returns string[] of written file paths. Use when adding platform support for a new agent, integrating a new code AI tool, or extending caliber to support new targets. Do NOT use for modifying existing writers, refactoring scoring logic, or changing how writers are invoked.