# CLI commands Source: https://docs.skillcreator.ai/cli/commands Complete reference for all SkillCreator CLI commands. ## `sc desktop status` Show the current runtime status, RPC endpoint, and database info. ```bash theme={"dark"} sc desktop status ``` Output includes: * RPC server endpoint and port * Database path and skill count * Active workspace roots * MCP server registration status ## `sc list` List all skills in the local library. ```bash theme={"dark"} sc list sc list --include-archived sc list --favorites sc list --names-only sc list --json ``` | Flag | Description | | -------------------- | -------------------------- | | `--include-archived` | Include archived skills | | `--favorites` | Show only favorited skills | | `--names-only` | Output skill names only | | `--json` | Output as JSON | ## `sc show ` Show detailed information about a skill. ```bash theme={"dark"} sc show conventional-commits ``` Displays: metadata, file list, latest eval scores, and version history. ## `sc search ` Search skills by name, description, or content. ```bash theme={"dark"} sc search "react testing" ``` ## `sc evaluate ` Run an evaluation on a skill and display the scores. The alias `sc eval` is also accepted. ```bash theme={"dark"} sc evaluate conventional-commits sc eval conventional-commits ``` Returns scores for all 6 quality dimensions and any improvement suggestions. ## `sc doctor` Check the health of your skill library. ```bash theme={"dark"} sc doctor ``` Reports: * Total skill count * Skills with missing required fields * Skills that have never been evaluated * Orphaned files * Database integrity ## `sc desktop roots` Manage workspace roots (directories scanned for skills). ```bash theme={"dark"} sc desktop roots list # List current roots sc desktop roots add # Add a root sc desktop roots discover # Auto-discover roots sc desktop roots rescan # Rescan all roots ``` ## `sc health [name]` Show runtime health overview or health for a specific skill. ```bash theme={"dark"} sc health sc health conventional-commits ``` ## `sc agents` List all supported agent runtimes and their skill install paths. ```bash theme={"dark"} sc agents ``` # CLI overview Source: https://docs.skillcreator.ai/cli/overview Use the SkillCreator CLI to manage skills from your terminal. The SkillCreator CLI (`skillcreator` or `sc`) provides terminal access to your local skill runtime. It connects to the same SQLite database as the desktop app. ## Installation The CLI is installed automatically with the desktop app at `~/.local/bin/skillcreator`. Verify the installation: ```bash theme={"dark"} sc --version ``` If the command is not found, ensure `~/.local/bin` is in your PATH: ```bash theme={"dark"} export PATH="$HOME/.local/bin:$PATH" ``` ## How it works The CLI communicates with the desktop app's local RPC server. This means: * The CLI connects to the desktop app's RPC server when available. If the desktop app is not running, the CLI falls back to a standalone local runtime. * Changes made via CLI are instantly reflected in the desktop app * The CLI has access to the same skill library, evals, and runtime data The CLI uses a token-authenticated connection to the RPC server. The token is stored in `~/Library/Application Support/SkillCreator/skillcreator/runtime.json` and managed automatically. ## Quick reference | Command | Description | | -------------------- | --------------------------------------- | | `sc desktop status` | Show runtime status and connection info | | `sc list` | List all skills | | `sc show ` | Show skill details | | `sc search ` | Search skills by keyword | | `sc evaluate ` | Run evals on a skill (alias: sc eval) | | `sc doctor` | Check skill library health | See [CLI commands](/cli/commands) for the full reference. # Agent runtimes Source: https://docs.skillcreator.ai/concepts/agent-runtimes How skills integrate with Claude Code, Cursor, Copilot, Codex, Gemini CLI, and VS Code. SkillCreator supports exporting skills to multiple AI coding agent runtimes. Each runtime has its own convention for loading instructions. ## Supported runtimes | Runtime | Skill location | Format | | -------------- | --------------------------------- | -------- | | Claude Code | `.claude/skills/` or `CLAUDE.md` | Markdown | | Cursor | `.cursor/skills/` | Markdown | | GitHub Copilot | `.github/copilot-instructions.md` | Markdown | | Codex CLI | `AGENTS.md` | Markdown | | Gemini CLI | `GEMINI.md` | Markdown | | Amp | `.amp/skills/` | Markdown | | Goose | `.goose/skills/` | Markdown | | OpenCode | `.opencode/skills/` | Markdown | ## How export works When you export a skill from SkillCreator, the app: 1. Reads the skill's frontmatter to determine the target runtime(s) 2. Converts the skill format to the runtime's expected structure 3. Shows a diff preview of what will change 4. Writes the file(s) to your project directory Exports are transactional. If something goes wrong, SkillCreator rolls back the changes. ## Claude Code Claude Code reads skills from two locations: * **`CLAUDE.md`**: the project instruction file that Claude Code reads * **`.claude/skills/`**: individual skill files loaded on demand SkillCreator can write to either location. For most skills, `.claude/skills/` is preferred because it keeps instructions modular. ## Cursor Cursor loads custom rules from `.cursor/rules/` in your project root. Each file becomes a separate rule that Cursor applies during code generation. ## GitHub Copilot Copilot reads repository-level instructions from `.github/copilot-instructions.md`. SkillCreator installs skills to `.github/skills/` as separate files. ## MCP integration Beyond file-based exports, SkillCreator also runs an MCP server that agents can query directly. This allows agents to: * List available skills * Read skill content on demand * Check skill health and eval scores * Search skills by tag or keyword See [MCP setup](/mcp/setup) for configuration details. # Skill format Source: https://docs.skillcreator.ai/concepts/skill-format The anatomy of a SKILL.md file: metadata, instructions, constraints, and verification. Every skill is a Markdown file with YAML frontmatter. Here is a complete example: ```yaml SKILL.md theme={"dark"} --- name: react-component version: 1.0.0 description: Create well-structured React components with TypeScript tags: [react, typescript, frontend] allowed-tools: [Bash, Read, Write] --- # React component creation ## Instructions 1. Create a new file in the appropriate directory under `src/components/` 2. Use functional components with TypeScript 3. Define props as a named interface: `interface ComponentNameProps` 4. Export the component as a named export ## Constraints - Never use `any` type; always define explicit types - Keep components under 200 lines - Co-locate styles, tests, and stories with the component - Use composition over inheritance ## Verification - [ ] Component renders without errors - [ ] Props interface is exported - [ ] Test file exists with at least one test - [ ] No TypeScript errors ## Examples ### Input "Create a Button component that supports primary and secondary variants" ### Output A `src/components/Button/` directory containing: - `Button.tsx`, the component - `Button.test.tsx`, tests - `index.ts`, re-export ``` ## Frontmatter fields | Field | Type | Required | Description | | ---------------- | --------- | -------- | ------------------------------------------------------------------- | | `name` | string | Yes | Unique identifier (kebab-case) | | `version` | semver | No | Skill version (stored in metadata sub-block, not a top-level field) | | `description` | string | Yes | One-line summary of what the skill does | | `tags` | string\[] | No | Categorization tags | | `author` | string | No | Skill author | | `allowed-tools` | string\[] | No | Claude Code tool names the skill may use | | `triggers` | string\[] | No | Activation phrases that invoke this skill | | `user-invocable` | boolean | No | Whether users can invoke directly via slash command | ## Sections ### Instructions The core of the skill. Write clear, numbered steps that tell the agent exactly what to do. Be specific; agents follow instructions literally. Use imperative mood: "Create a file" not "You should create a file." ### Constraints Rules the agent must follow. Constraints prevent common mistakes and enforce your team's conventions. Vague constraints like "write clean code" are not useful. Be specific: "Keep functions under 50 lines" or "Never use `console.log` in production code." ### Verification A checklist the agent can use to validate its own output. Each item should be independently verifiable. ### Examples Concrete input/output pairs show the agent exactly what behavior you expect. ## Multi-file skills Complex skills can span multiple files in a directory: The `SKILL.md` file is the entry point. Additional files provide templates, examples, or reference material that the skill can point to. # What are skills? Source: https://docs.skillcreator.ai/concepts/skills Agent skills are structured instruction files that teach AI coding agents how to perform specific tasks. A **skill** is a structured Markdown file, typically named `SKILL.md`, that contains everything an AI coding agent needs to perform a specific task reliably. ## The problem skills solve AI coding agents like Claude Code, Cursor, and Copilot are powerful but generic. Without specific instructions, they: * Guess at your project's conventions * Miss domain-specific requirements * Produce inconsistent results across sessions * Cannot learn from corrections They give agents **persistent, structured knowledge** about how to do things in your specific context. ## What a skill contains A skill typically includes: | Section | Purpose | | ---------------- | ----------------------------------------------- | | **Metadata** | Name, version, description, tags, target agents | | **Instructions** | Step-by-step directions for the task | | **Constraints** | Rules and guardrails the agent must follow | | **Verification** | How to check that the output is correct | | **Context** | Background information, conventions, examples | | **Examples** | Sample inputs and expected outputs | ## Skills vs. prompts | | Prompt | Skill | | ----------- | ------------------------------ | --------------------------------- | | Format | Free text | Structured Markdown with metadata | | Persistence | One-off, lives in chat history | Versioned file on disk | | Reusability | Copy-paste | Install once, use across sessions | | Quality | Varies | Scored on 6 dimensions | | Sharing | Screenshots, gists | Export, import, or publish | ## Skills across agents Skills are designed to be **agent-agnostic**. The same skill can be installed into: * **Claude Code** via `.claude/skills/` files or CLAUDE.md sections * **Cursor** via `.cursor/skills/` files * **GitHub Copilot** via `.github/copilot-instructions.md` * **Codex CLI** via `AGENTS.md` * **Gemini CLI** via `GEMINI.md` * **Amp** via `.amp/skills/` files * **Goose** via `.goose/skills/` files SkillCreator handles the format conversion automatically when you export. ## Skill lifecycle ```mermaid theme={"dark"} flowchart LR A[Create] --> B[Edit] B --> C[Evaluate] C --> D[Install] D --> E[Use] E --> F[Patch] F --> C ``` 1. **Create.** Write from scratch, generate with AI, or convert existing docs. 2. **Edit.** Refine instructions, add constraints, include examples. 3. **Evaluate.** Score quality and fix gaps. 4. **Install.** Deploy to one or more agent runtimes. 5. **Use.** Agents follow the skill during coding sessions. 6. **Patch.** Update based on real-world performance. # Editor Source: https://docs.skillcreator.ai/desktop/editor A full IDE for editing skills with Monaco, file tree, frontmatter panel, and insights. The Editor provides a complete development environment for individual skills. ## Layout The editor has four panels: * **File tree** (left). Navigate files in a multi-file skill. * **Code editor** (center). Monaco editor with Markdown syntax highlighting. * **Inspector panel** (right). Tabbed panel with Overview, Metadata, Validation, and Insights sub-tabs. * **Tabs** (top). Switch between open files. ## Monaco editor The code editor is powered by Monaco (the same engine as VS Code). Features include: * Markdown syntax highlighting * Auto-save * Find and replace * Multi-cursor editing * Bracket matching * Word wrap ## Metadata tab The metadata tab provides a form-based interface for editing skill metadata: * Name and description * Tags (add/remove with chips) * Allowed tools (tool selector) * User invocable (switch) * License Changes in the metadata tab sync immediately with the YAML frontmatter in the file. ## Insights The Editor provides real-time insights about your skill: | Insight | Description | | ------------------ | ---------------------------------------------------- | | Token budget | Estimated token count when loaded by an agent | | File relationships | How files in a multi-file skill reference each other | | Orphaned files | Files that exist but are not referenced | | Validation | Structural issues like missing required fields | ## Tabs Each Editor tab corresponds to an open file. You can open multiple skills at once by using the file tree or the command palette. Use the insights panel to keep your skills within token budget. Large skills may be truncated or ignored by some agent runtimes. # Evals Source: https://docs.skillcreator.ai/desktop/evals Score skill quality on 6 dimensions and track improvements over time. The Evals system scores your skills against 6 quality dimensions and tracks scores over time so you can catch regressions. ## Quality dimensions | Dimension | What it measures | | ------------- | ---------------------------------------------------------- | | **Structure** | Is the skill well-organized with clear sections? | | **Content** | Does the skill cover the task with sufficient depth? | | **Evidence** | Are claims backed by references or links? | | **Usage** | Does the skill include example prompts and usage patterns? | | **Toolchain** | Are tool requirements and allowed-tools specified? | | **Freshness** | Is the content current and recently maintained? | Each dimension is scored independently. The overall score is a weighted aggregate. ## Running evals 1. Open a skill in the Editor or Library 2. Navigate to the **Evals** tab 3. Click **Run evaluation** 4. Review the scores and any flagged issues Evals run locally. No data is sent to external services. ## Score history Every eval run is recorded with a timestamp. The Evals view shows: * **Score trends.** The latest 5 scores shown per skill as a text sequence. * **Run history.** Full list of past runs with scores and timestamps. * **Run heatmap.** Visual overview of agent skill usage (success/failure) over time. This tracks when agents used the skill, not eval runs. ## Improvement suggestions When a dimension scores below threshold, the eval system provides specific suggestions: * Missing overview section * Short or thin content that needs expansion * No concrete examples with input/output * No references or evidence links * Missing tags in frontmatter # Graph Source: https://docs.skillcreator.ai/desktop/graph Visualize skill dependencies and relationships on an interactive canvas. The Graph view renders your skills as nodes on an interactive canvas, with edges representing dependencies and relationships between them. ## Canvas interactions | Action | Effect | | ----------------------- | ------------------------------ | | Click node | Select and highlight the skill | | Drag node | Reposition on canvas | | Scroll | Zoom in/out | | Click + drag background | Pan the canvas | | Double-click node | Open skill in Editor | ## Adding skills Add skills to the graph from: * Your local library (search by name) * A URL pointing to a skill file * The command palette ## Edge types Edges between skills indicate relationships: | Edge type | Meaning | | -------------- | ------------------------------------------------- | | **depends-on** | This skill requires another to work properly | | **extends** | This skill builds on another skill's instructions | | **chains-to** | This skill feeds output to another | | **recommends** | This skill suggests using another | | **conflicts** | These skills should not be used together | ## Graph properties The Graph panel shows aggregate stats: * Total nodes and edges * Disconnected clusters ## Export Graph data can be exported as JSON for sharing or backup. # Library Source: https://docs.skillcreator.ai/desktop/library Browse, search, and manage your local skill collection. The Library is your local skill index. Every skill on your machine is indexed in a SQLite database and available for search, filtering, and management. ## Browsing skills The Library displays skills in a scrollable list. Each card shows: * Skill name and slug * Source label * Agent adapter family ## Search and filter Use the search bar at the top to find skills by name, description, or tag. Results update as you type, with a short debounce delay. ## Skill actions Each skill card has inline action buttons: | Action | Description | | -------------- | ------------------------------------- | | Open in Editor | Edit the skill in the full IDE | | Run evals | Score the skill on quality dimensions | | Archive | Move to archive (recoverable) | ## Workspace roots SkillCreator scans configured workspace directories for skills. You can add or remove workspace roots in Settings, and manually trigger a re-index when files change. ## Versioning Skills are versioned automatically via content hashing. Each change creates a new version entry in the local database. # Desktop app overview Source: https://docs.skillcreator.ai/desktop/overview Navigate the SkillCreator desktop workspace: Studio, Library, Editor, Evals, Graph, and Terminal. The SkillCreator desktop app is a three-panel workspace for the full skill lifecycle. ## Layout The app has three main areas: * **Sidebar** (left). Navigate between views. Collapsible with the toggle at the top. * **Main area** (center). The active view: Studio, Library, Editor, Evals, Graph, or Settings. * **Terminal** (bottom). An embedded PTY for running agents. Toggle with `Cmd+J`. ## Views | View | Purpose | | -------- | ---------------------------------------------------------- | | Studio | Generate skills from prompts, URLs, docs, or images | | Library | Browse, search, and manage all skills | | Editor | Edit a skill with Monaco, file tree, and frontmatter panel | | Evals | Score and track skill quality | | Graph | Visualize skill dependencies | | Settings | App preferences, theme, data management | ## Keyboard shortcuts | Shortcut | Action | | -------- | ------------------------------------ | | `Cmd+K` | Open command palette | | `Cmd+J` | Toggle terminal panel | | `Cmd+N` | Start new skill creation in terminal | | `Cmd+R` | Re-index workspace skills | ## Command palette Press `Cmd+K` to open the command palette. It provides search across: * Navigation (switch views) * Skills (open a skill by name) * Actions (run evals, generate, export) * Recent items ## Themes SkillCreator supports light, dark, and system themes. Change the theme in Settings or use the toggle at the bottom of the sidebar. ## Data storage All data is stored locally: | Data | Location | | --------------- | ---------------------------------------------------------------------- | | Skills database | `~/Library/Application Support/SkillCreator/skillcreator/` | | App logs | `~/Library/Logs/SkillCreator/` | | Window state | `~/.skillcreator/window-state.json` | | Runtime state | `~/Library/Application Support/SkillCreator/skillcreator/runtime.json` | # Studio Source: https://docs.skillcreator.ai/desktop/studio Generate AI agent skills from prompts, URLs, documents, and images. The Studio is where you create new skills. It accepts natural language prompts and source materials, then generates structured SKILL.md files using AI. ## Input methods ### Prompt Type a description of the task your agent should learn: ``` Create a skill that teaches Claude Code how to write database migrations with proper up/down scripts, transaction safety, and rollback procedures. ``` ### Build from sources Upload local files and folders into the Studio. Supported formats include Markdown, plain text, code files, HTML, and configuration files. ### File upload Drag and drop files into the Studio. Supported formats include Markdown, plain text, and code files. ### Image Upload a screenshot or diagram. The Studio uses vision to extract structure and convert it into skill instructions. ## Generation methods The Studio supports multiple generation strategies: | Method | Use when | | ---------------------- | ------------------------------------------------ | | **Prompt** | You can describe the task from scratch | | **Build from sources** | You have local files, folders, or code to import | | **Image to skill** | You have a screenshot or diagram of the workflow | ## Generation output After generation, the Studio produces: * A structured SKILL.md file with frontmatter, instructions, constraints, and verification * Organized into folders if multiple skills are generated * Each result card shows the skill name, description, and quick actions ## History The Studio keeps a history of all generations in the sidebar. You can revisit any previous generation, view the original prompt, and view the results in the Manager. Start with a specific, concrete prompt. "Write a skill for React component testing with React Testing Library" will produce better results than "write a testing skill." # Terminal Source: https://docs.skillcreator.ai/desktop/terminal An embedded terminal for running agents directly inside SkillCreator. The Terminal panel provides a full PTY (pseudo-terminal) at the bottom of the workspace. Use it to run AI agents, test skills, and execute commands without leaving the app. ## Opening the terminal | Action | Method | | ------------- | ------------------------------------------------------- | | Toggle | `Cmd+J` | | New skill | `Cmd+N` (starts skill creation in terminal) | | Resize | Drag the top edge of the panel | | Toggle height | Double-click the top edge (toggles between 30% and 50%) | ## Features * **Full PTY.** Runs your default shell (zsh/bash) with complete terminal emulation. * **PTY backend.** Up to 10 PTY processes managed internally. * **Resizable.** Drag to resize, defaults to 30% of window height. * **Persistent.** Terminal sessions persist across view switches. ## CLAUDE.md injection When you open a terminal in a workspace directory, SkillCreator automatically writes a `CLAUDE.md` file into that workspace with: * SkillCreator context and available MCP tools * Instructions for Claude Code to interact with your skill library * An onboarding skill installed to `.claude/skills/` This means Claude Code automatically knows about your skills when you start it from the terminal. The injected CLAUDE.md uses sentinel markers to update only the SkillCreator section. If you have a custom CLAUDE.md, your content outside the markers is preserved. ## Using with agents A typical workflow: 1. Open the terminal with `Cmd+J` 2. Navigate to your project directory 3. Start Claude Code: `claude` 4. Claude automatically loads the SkillCreator MCP tools 5. Ask Claude to use your skills: "Use the react-component skill to create a Button" # Convert existing docs to skills Source: https://docs.skillcreator.ai/guides/convert-docs Turn runbooks, READMEs, and documentation into structured agent skills. If your team already has documentation, runbooks, or coding guidelines, you can convert them into structured skills instead of writing from scratch. ## Using the Studio Navigate to the Studio and select **Build from Local Sources**. Upload the files you want to convert. The Studio accepts: * README sections * Runbooks and playbooks * Style guides * API documentation * Code review checklists * Onboarding documents The AI analyzes your files and produces a structured SKILL.md with: * Extracted metadata (name, description, tags) * Reorganized instructions in step format * Inferred constraints from your guidelines * Generated verification criteria The converted skill opens in the Editor. Review each section and refine: * Tighten vague constraints * Add concrete examples * Remove information that is not actionable for an agent ## Tips for good conversions The best source documents are ones that describe **how** to do something, not **what** something is. Procedural content converts better than conceptual content. * Focus on one task per conversion; split large docs into multiple skills * After conversion, always run evals to catch gaps * Add examples if the source document did not include them # Improve skill quality with evals Source: https://docs.skillcreator.ai/guides/eval-quality Use the evaluation system to systematically improve your skills. The eval system helps you find and fix weaknesses before deploying. ## The eval workflow ```mermaid theme={"dark"} flowchart LR A[Write skill] --> B[Run eval] B --> C{Score OK?} C -->|Yes| D[Deploy] C -->|No| E[Fix issues] E --> B ``` ## Common issues and fixes ### Low completeness score The skill does not cover all aspects of the task. **Fix:** Ask yourself "what would a new team member need to know?" Add missing steps, edge cases, and error handling instructions. ### Low clarity score Instructions are ambiguous or could be interpreted multiple ways. **Fix:** Replace vague language with specific actions: | Before | After | | ----------------------------- | ------------------------------------------------------------------------------------ | | "Handle errors appropriately" | "Wrap database calls in try/catch and return a 500 status with the error message" | | "Use good naming" | "Use camelCase for variables, PascalCase for components, UPPER\_SNAKE for constants" | | "Follow best practices" | Remove entirely, this adds no information | ### Low constraints score The skill does not set clear boundaries. **Fix:** Add specific, measurable constraints: * File size limits * Naming conventions * Forbidden patterns * Required dependencies ### Low verification score The agent cannot check its own work. **Fix:** Add a verification checklist with items that can be independently checked. Each item should be binary: it either passes or fails. ### Low context score The skill assumes knowledge the agent may not have. **Fix:** Add background sections explaining domain concepts, project conventions, or architectural decisions that inform the instructions. ### Low structure score The skill is poorly organized or uses inconsistent formatting. **Fix:** Follow the standard section order: Overview, Instructions, Example Prompts. Use consistent heading levels and list formatting. ## Tracking improvements The Evals view shows sparkline trends per skill. Use these to: * Verify that edits actually improved scores * Catch regressions when updating skills * Compare quality across your skill library # Build your first skill Source: https://docs.skillcreator.ai/guides/first-skill A hands-on walkthrough of creating a skill from scratch. This guide walks through creating a complete skill manually, without the AI generator. This helps you understand the format and write better prompts for the Studio. ## What we are building A skill that teaches Claude Code how to write Git commit messages following the Conventional Commits specification. ## Step 1: Create the file In the Editor, create a new file called `SKILL.md`: ```yaml SKILL.md theme={"dark"} --- name: conventional-commits description: Write Git commit messages following the Conventional Commits spec tags: [git, conventions, workflow] allowed-tools: [Bash, Read, Write] --- ``` ## Step 2: Write the instructions ```markdown theme={"dark"} # Conventional commits ## Instructions 1. Analyze the staged changes using `git diff --cached` 2. Determine the commit type based on the nature of the changes 3. Write a commit message in the format: `type(scope): description` 4. If the change is breaking, add `!` after the type/scope 5. Add a body if the change needs explanation beyond the subject line 6. Add footer(s) for breaking changes or issue references ``` ## Step 3: Add constraints ```markdown theme={"dark"} ## Constraints - Subject line must be under 72 characters - Use imperative mood: "add feature" not "added feature" - Do not capitalize the first letter of the description - Do not end the subject line with a period - Allowed types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert - Scope is optional but recommended for monorepos ``` ## Step 4: Add verification ```markdown theme={"dark"} ## Verification - [ ] Commit type is one of the allowed types - [ ] Subject line is under 72 characters - [ ] Description uses imperative mood - [ ] Breaking changes are marked with `!` and documented in footer - [ ] Related issues are referenced in footer ``` ## Step 5: Add examples ```markdown theme={"dark"} ## Examples ### Simple feature `feat(auth): add password reset flow` ### Bug fix with scope `fix(api): handle null response from payment provider` ### Breaking change `feat(api)!: remove deprecated v1 endpoints` ``` BREAKING CHANGE: The /v1/\* endpoints have been removed. Migrate to /v2/\* before upgrading. ``` ``` ## Step 6: Run evals Navigate to the Evals view in the main navigation, enter the skill ID, and run an evaluation. You should see high scores across 6 dimensions: Structure, Content, Evidence, Usage, Toolchain, and Freshness. If any dimension is flagged, review the suggestions and improve that section. ## Step 7: Install Open the skill in the Library, go to the Deploy tab, and install to Claude Code. SkillCreator writes the skill directory to `~/.claude/skills/conventional-commits/`. The next time you use Claude Code, it will follow these commit conventions automatically. # Skills across multiple agents Source: https://docs.skillcreator.ai/guides/multi-agent Share the same skills across Claude Code, Cursor, Copilot, and other agent runtimes. SkillCreator skills are agent-agnostic. Write a skill once, export it to multiple runtimes. ## Export to multiple agents When exporting a skill, you can select multiple target agents. SkillCreator handles the format conversion for each runtime. From the Editor or Library, click **Export**. Check the agent runtimes you want to export to: * Claude Code (`.claude/skills/`) * Cursor (`.cursor/skills/`) * GitHub Copilot (`.github/skills/`) * Codex CLI (`AGENTS.md`) SkillCreator shows a diff preview for each target. Review what will be added, modified, or removed. Click **Install** to write all files. Each export is transactional; if any write fails, all changes are rolled back. ## Keeping skills in sync After updating a skill, re-deploy to update the installed copies. ## MCP as a universal layer Instead of file-based exports, you can use the MCP server as a universal skill provider. Agents that support MCP can query skills directly from your SkillCreator runtime. This means: * No file duplication across agent configs * Skills are always up to date * Agents can discover skills dynamically See [MCP overview](/mcp/overview) for details. Use file exports for skills you want to be available without SkillCreator running. Use MCP for dynamic, always-current skill access. # SkillCreator Source: https://docs.skillcreator.ai/index A native desktop IDE for building, managing, and evaluating AI agent skills. SkillCreator is a macOS desktop app for creating **agent skills**, structured Markdown instruction files that teach AI coding agents how to perform specific tasks. Skills work across Claude Code, GitHub Copilot, Cursor, Codex, Gemini CLI, and more. Build your first skill in under 5 minutes. Download the desktop app for macOS. Understand the skill format and how agents use them. ## Why SkillCreator? Most AI coding agents accept plain-text instructions, but there is no standard way to create, version, test, or share those instructions. SkillCreator gives you a dedicated workspace: * **Studio.** Generate skills from prompts, URLs, docs, or images using AI. * **Editor.** Full IDE with Monaco, file tree, frontmatter editing, and validation. * **Library.** SQLite-backed local index of all your skills with search, tags, and versioning. * **Evals.** Score skills on 6 quality dimensions and track regressions over time. * **Graph.** Visualize skill dependencies on an interactive canvas. * **Terminal.** Embedded PTY for running agents directly inside the app. ## How it works Paste a URL, drop files, or describe what you want the agent to do. The Studio ingests your sources and extracts structure. AI synthesizes a structured SKILL.md with metadata, instructions, constraints, and verification steps. Run quality evals that score structure, content, evidence, usage, toolchain, and freshness. Export to any agent runtime (Claude Code, Cursor, Copilot, Codex, Amp, and more) with a transactional install that previews diffs and supports rollback. ## Architecture SkillCreator stores all data locally in a SQLite database. Skill generation requires an API connection; the app itself stores all data locally and does not send skill content to any server. An optional MCP server exposes your skill library to AI agents for live introspection. ```mermaid theme={"dark"} flowchart LR A[Studio / Editor] --> B[Local SQLite Runtime] B --> C[Skill Files on Disk] B --> D[MCP Server] D --> E[Claude Code] D --> F[Cursor] D --> G[Other Agents] ``` # Installation Source: https://docs.skillcreator.ai/installation Download and install SkillCreator for macOS. ## System requirements | Requirement | Details | | ------------ | ----------------------------------- | | OS | macOS 11 (Big Sur) or later | | Architecture | Apple Silicon (M1+) | | Disk space | \~115 MB | | Runtime | No additional dependencies required | ## Download Download the latest `.dmg` from [skillcreator.ai](https://skillcreator.ai). Visit [skillcreator.ai](https://skillcreator.ai) and click **Download for macOS**. Open the `.dmg` file and drag SkillCreator into your Applications folder. Open SkillCreator from Applications. On first launch, macOS may ask you to confirm since the app was downloaded from the internet. ## What happens on first launch When SkillCreator starts for the first time, it: 1. Creates a local SQLite database at `~/Library/Application Support/SkillCreator/skillcreator/` 2. Starts a local RPC server for CLI and MCP access 3. Auto-registers the MCP server with detected agent runtimes (Claude Code, Cursor, Gemini CLI, Claude Desktop) 4. Installs the `skillcreator` CLI to `~/.local/bin/` (with `sc` alias) The app works fully offline. No account or internet connection is required for core functionality. ## CLI installation The CLI is bundled with the desktop app and installed automatically. Verify it works: ```bash theme={"dark"} skillcreator --version # or use the short alias sc --version ``` If the command is not found, add `~/.local/bin` to your PATH: ```bash theme={"dark"} export PATH="$HOME/.local/bin:$PATH" ``` ## Auto-updates SkillCreator checks for updates automatically on launch. When an update is available, a banner appears at the top of the app. Updates are downloaded in the background and applied on next restart. ## Uninstall 1. Quit SkillCreator 2. Delete from Applications 3. Optionally remove data: `rm -rf ~/Library/Application\ Support/SkillCreator` 4. Optionally remove CLI: `rm ~/.local/bin/skillcreator ~/.local/bin/sc` # MCP overview Source: https://docs.skillcreator.ai/mcp/overview Expose your skill library to AI agents via the Model Context Protocol. SkillCreator includes an MCP (Model Context Protocol) server that lets AI agents query your skill library directly. Instead of reading static files, agents can discover, inspect, and use skills dynamically. ## What MCP enables With the MCP server running, an AI agent can: * **List skills.** Browse your entire skill library. * **Read skills.** Load skill content on demand. * **Check health.** View eval scores and quality metrics. * **Search.** Find skills by keyword or tag. * **Inspect runs.** View skill execution history. ## How it works ```mermaid theme={"dark"} flowchart LR A[AI Agent] -->|MCP Protocol| B[SkillCreator MCP Server] B -->|RPC| C[Desktop Runtime] C --> D[SQLite Database] C --> E[Skill Files] ``` The MCP server is a stdio-based server that proxies all tool calls to the desktop app's local RPC endpoint. It runs as a subprocess of the desktop app. ## Auto-registration On first launch, SkillCreator automatically registers its MCP server with detected agent runtimes: | Runtime | Config file | | -------------- | ----------------------------------------------------------------- | | Claude Code | `~/.claude.json` | | Cursor | `~/.cursor/mcp.json` | | Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` | | Gemini CLI | `~/.gemini/settings.json` | Auto-registration only adds the server entry if the config file exists. It does not overwrite existing configurations. Auto-registration also writes tool approval permissions to `~/.claude/settings.json` for Claude Code. ## Headless mode The MCP server can run independently of the desktop app: ```bash theme={"dark"} skillcreator --skillcreator-mcp ``` This starts a headless MCP server that connects to the local runtime. Useful for CI environments or when you want MCP without the GUI. # MCP setup Source: https://docs.skillcreator.ai/mcp/setup Configure the SkillCreator MCP server for your agent runtime. ## Automatic setup SkillCreator auto-registers its MCP server on first launch. If you see SkillCreator tools available in your agent, no manual setup is needed. ## Manual setup If auto-registration did not work, add the server manually. ### Claude Code Add to `~/.claude.json`: ```json theme={"dark"} { "mcpServers": { "skillcreator": { "command": "skillcreator", "args": ["--skillcreator-mcp"] } } } ``` ### Cursor Add to `~/.cursor/mcp.json`: ```json theme={"dark"} { "mcpServers": { "skillcreator": { "command": "skillcreator", "args": ["--skillcreator-mcp"] } } } ``` ### Claude Desktop Add to `~/Library/Application Support/Claude/claude_desktop_config.json`: ```json theme={"dark"} { "mcpServers": { "skillcreator": { "command": "skillcreator", "args": ["--skillcreator-mcp"] } } } ``` ### Gemini CLI Add to `~/.gemini/settings.json`: ```json theme={"dark"} { "mcpServers": { "skillcreator": { "command": "skillcreator", "args": ["--skillcreator-mcp"] } } } ``` ## Verify the connection After setup, start your agent and check that SkillCreator tools are available: ```bash theme={"dark"} claude # Then ask: "What SkillCreator tools are available?" ``` Open Cursor and check the MCP tools panel for `skillcreator` tools. ## Troubleshooting Ensure the desktop app is running. The MCP server needs the local RPC endpoint to be active. Check that `skillcreator` is in your PATH: ```bash theme={"dark"} which skillcreator ``` The RPC server may not be running. Check `~/.skillcreator/runtime.json` for the current endpoint and verify the desktop app is open. If you reinstalled SkillCreator, the auth token may have changed. Delete the MCP server entry from your agent's config and restart SkillCreator to re-register. # MCP tools Source: https://docs.skillcreator.ai/mcp/tools Complete reference for all MCP tools exposed by SkillCreator. The SkillCreator MCP server exposes the following tools to AI agents. ## Skill management ### `get_status` Get the current runtime status. **Parameters:** None **Returns:** Runtime version, database path, skill count, uptime. ### `search_skills` Search skills by keyword. **Parameters:** Search query string. **Returns:** Array of matching skills with name, description, and relevance score. ### `inspect_skill` Get detailed information about a specific skill. Skill name (kebab-case identifier). **Returns:** Full skill metadata, content, file list, and latest eval scores. ## Health and evaluation ### `get_health_overview` Get aggregate health metrics across all skills. **Parameters:** None **Returns:** Total skills, average scores, skills needing attention, recent eval activity. ### `get_skill_health` Get health metrics for a specific skill. Skill name. **Returns:** Eval scores per dimension, trend direction, last eval date, improvement suggestions. ### `get_eval_trend` Get eval score history for a skill. Skill name. Maximum number of eval runs to return. **Returns:** Array of eval runs with timestamps and scores. ## Run history ### `get_run_history` Get execution history for a skill. Skill name. Maximum number of runs to return. **Returns:** Array of skill runs with timestamps, agent runtime, and outcome. ### `report_run` Report a skill execution (used by agents to log skill usage). Skill name. Agent runtime that used the skill. Execution outcome: `success`, `partial`, or `failure`. **Returns:** Confirmation of recorded run. ## Additional tools The following tools are also available but not fully documented here: * `list_skills` - List all skills in the library, with optional filters. * `get_skill` - Get a skill by ID. * `create_skill` - Create a new skill. * `delete_skill` - Delete a skill by ID. * `read_skill_file` - Read the content of a file within a skill. * `write_skill_file` - Write or update a file within a skill. * `run_eval` - Trigger an evaluation run for a skill. * `install_skill` - Install a skill into an agent runtime. * `preview_install` - Preview what installing a skill would do, without making changes. * `detect_agents` - Detect which agent runtimes are present on the system. # Quickstart Source: https://docs.skillcreator.ai/quickstart Build your first AI agent skill in under 5 minutes. This guide walks you through creating, evaluating, and installing your first skill using the SkillCreator desktop app. ## Prerequisites * macOS (Apple Silicon or Intel) * One of: Claude Code, Cursor, GitHub Copilot, Codex CLI, Gemini CLI, or VS Code ## Create your first skill Launch SkillCreator and click **Studio** in the sidebar. You will see a prompt input with options to add context from URLs, files, or images. Type a natural-language description of the task your agent should learn. For example: ``` Write a skill that teaches Claude Code how to create well-structured React components with TypeScript, proper prop types, and test files. ``` You can also paste a URL to existing documentation, drag in files, or upload a screenshot. Click **Generate Skill**. The Studio will analyze your input, extract key patterns, and produce a structured SKILL.md file with: * Metadata (name, description, allowed-tools) * Overview section * Step-by-step instructions * Example prompts The generated skill appears as an inline card in the Studio. You can edit it there, or save it to the Library and open it in the full Editor. You can also: * Edit the Markdown directly in the Monaco editor * Adjust metadata in the frontmatter panel * Add or remove files in the file tree * View token budget and file relationship insights Switch to the **Evals** tab and click **Run evaluation**. The system scores your skill on 6 dimensions: * Structure * Content * Evidence * Usage * Toolchain * Freshness Fix any flagged issues and re-run until you are satisfied. Open the skill in the Library, then go to the **Deploy** tab and select your target agent runtime. SkillCreator shows a file-level diff preview of what will be added or changed. Confirm the install. Your agent now knows the skill. ## What's next? Learn the anatomy of a SKILL.md file. Turn runbooks, READMEs, and docs into skills.