> ## Documentation Index
> Fetch the complete documentation index at: https://support.bolt.new/llms.txt
> Use this file to discover all available pages before exploring further.
# Use skills to apply reusable instructions
> Learn how to add rules and workflows Bolt can apply while planning or building.
Skills are reusable instructions that teach Bolt how to handle specific scenarios. Each skill has a name, a description that tells Bolt when to apply it, and the instructions themselves.
Use a skill for rules or workflows you need often, like UI copy guidelines or a launch checklist. Add your instructions and Bolt follows them automatically when [planning](/best-practices/discussion-mode) and building, so you don't have to explain them every time.
Get started by [writing a skill](#write-instructions-manually), [asking Bolt to write one for you](#create-a-skill-from-chat), or [importing a skill](#add-a-skill) from a source you trust.
After a skill is in your workspace, you can turn it on in any project. Then, Bolt applies it whenever your prompt matches the skill's description, or you can apply it manually by typing `/$skill-name` in the chat.
## What's the difference between skills and knowledge?
Skills only apply in certain situations (defined in the skill description), while knowledge applies to every prompt.
| | When to use it | Example |
| ------------- | ----------------------------------------------------------- | --------------------------------------------------------------------------------- |
| **Skills** | Use for repeatable workflows and instructions. | "Use this checklist to test pages in the app against my accessibility guidelines" |
| **Knowledge** | Gives Bolt persistent context that applies to every prompt. | "This project is a mobile app built on React.js" |
If you want Bolt to interact with an external tool (like getting information from Linear) you need a connector, not a skill. Connectors give Bolt access to external tools and live data. To learn more, see [Connect an MCP server](/building/using-bolt/connect-mcp).
## Workspace, project, and Bolt-curated skills
Skills are available at the workspace level and the project level. You can add skills yourself or use built-in skills that Bolt manages for you.
### Workspace skills
Skills you add in **Workspace** > **[Skills library](#skills-library-workspace)** are available to [turn on or off](#turn-skills-on-or-off-in-a-project) in individual projects.
In a Team workspace, this appears under your team's name instead of the label **Workspace**.
### Project skills
Skills you add in **Project settings** > **[Skills](#skills-project)** are stored in your project's code. They're always turned on.
Skills available in your workspace can be on or off by default for each project, depending on the workspace type:
* **Personal workspaces**: Skills are turned on by default in each project.
* **Team workspaces**: Admins add skills, and they're turned off by default. Team members [turn them on](#turn-skills-on-or-off-in-a-project).
### Bolt-curated skills
Bolt maintains a built-in set of skills you can turn on in your projects. Unlike skills you add, you can't edit or remove Bolt-curated skills.
Bolt-curated skills include:
* SEO/GEO
* Skill Creator
* Web Design Guidelines
* Writing Guidelines
Skill Creator lets Bolt create skills for you in the chat. It's always turned on.
Other Bolt-curated skills are turned off by default. To use them, [turn them on in your project](#turn-skills-on-or-off-in-a-project).
## Go to your Skills settings
Workspace and project skills have their own settings where you add or manage available skills.
### Skills library (workspace)
You can open the Skills library from the Bolt homepage or from inside a project.
1. In the top-left corner of the screen, click the account dropdown, then click **Settings**.
2. In the left navigation, click **Skills library**.
### Skills (project)
1. Open your Bolt project.
2. In the top menu, click the **gear icon**, then click **Skills**.
## Use skills safely
Before importing a skill, read the SKILL.md file completely so you know what instructions you're giving Bolt. Only use skills from developers or organizations you know and trust, or that you've read through yourself and fully understand. If a skill contains URLs you don't recognize, requests for sensitive information (like credentials or API keys), or instructions that change Bolt's behavior outside the scope of the task, it might be unsafe. If anything looks off, don't import the skill. Find another skill on the same topic, or write one yourself.
## Add a skill
Before you add a skill, decide where it should live. If you want it available for every project, add it to your workspace. If you only need it in one project, add it directly to that project.
If a project skill and a workspace skill have the same name, Bolt uses the workspace skill. To avoid conflicts, give each skill a unique name.
There are a few different ways to add skills. The following table shows where each method is available.
| Method | Workspace | Project |
| ------------------ | --------- | ------- |
| Write manually | ✓ | ✓ |
| Import from GitHub | ✓ | ✓ |
| Import from a file | ✓ | ✓ |
| Create from chat | | ✓ |
* To add a workspace skill, open the [Skills library](#skills-library-workspace).
* To add a project skill, open your project's [Skills page](#skills-project) or start chatting with Bolt.
### Import skills from GitHub
You can import skills from GitHub into a workspace or project.
1. Open the [Skills library](#skills-library-workspace) or your project's [Skills](#skills-project) page.
2. Click **Add skill**, then click **From GitHub**.
3. For each skill you want to import:
1. In **Repository URL**, enter a public GitHub repository.
Bolt automatically finds skills in the repo.
2. In the **Skill folder name** field, click the skill you want to import. If the repo contains a large number of skills, Bolt shows the first 100.
To see the skill's description before importing it, point to the **question mark icon**.
4. Click **Create**.
When Bolt finishes importing a skill, you'll see it listed among your available skills. If you added it from the Skills library, it shows under **In your workspace**. If you added it from your project's Skills page, it shows under **In this project**.
Imported GitHub skills can be up to 2 MB in size.
### Write instructions manually
In Team workspaces, only admins can write a skill to the workspace library. Any team member can write a skill directly in a project.
For help writing an effective skill, including examples of each part, see [Skills file requirements](#skills-file-requirements).
1. Open the [Skills library](#skills-library-workspace) or your project's [Skills](#skills-project) page.
2. Click **Add skill**, then click **Write manually**.
3. Fill out the different parts of the skill:
* **Skill name:** Add a unique name in the format `your-skill-name`.
* **Description:** Describe what the skill does and when Bolt should use it.
* **Instructions:** The complete instructions to define what the skill does.
4. Click **Create**.
Skills you write can be up to 256 KB in size.
### Import from a file
You can import skills from a file into a workspace or project. Skills files must use a `.md` or `.mdx` file extension, or a `.zip` file containing `.md` or `.mdx` files.
A `.zip` file can only contain one skill file, but you can include other Markdown files with examples for Bolt to reference when applying the skill.
1. Open the [Skills library](#skills-library-workspace) or your project's [Skills](#skills-project) page.
2. Click **Add skill**, then click **Import from file**.
3. Choose the `.md`, `.mdx`, or `.zip` file you want, then click **Import**.
Skills files have rules around their size and format. If you experience any problems importing your skills file, check that your file meets the [skills file requirements](#skills-file-requirements).
Individual `.md` or `.mdx` files can be up to 256 KB in size. `.zip` files can be up to 2 MB in size, including a 256 KB limit for the included skills file.
### Create a skill from chat
Bolt has a built-in `/skill-creator` skill it can use to write a skill for you. If you have a workflow in mind, describe it and ask Bolt to create it as a skill. You can also ask Bolt to create a skill based on the work you've done in chat. If you discover a great workflow while building, this lets you save and reuse it later.
When Bolt creates a skill, it's saved in that project and turned on automatically. You can see it on your project's Skills page, under **In this project**.
You can start creating a skill from the chatbox, or in your project's Skills page, click **Add skill** > **Build with Bolt**.
## Turn skills on or off in a project
When a skill is turned on, Bolt applies it automatically when your prompt matches the skill's description, and you can apply it by typing `/$skill-name` in the chat.
Skills have to be turned on for Bolt to use them. If you turn off a skill, you can't select it in that project, and Bolt won't automatically apply it, either.
You can turn workspace skills on or off per project so that only ones that fit the project get applied. Skills you add to a project or create from chat are always on for that project. If your project is shared, skills you turn on are available to all collaborators working in the project.
| How the skill was added | Projects in a personal workspace | Projects in a team workspace |
| ----------------------- | -------------------------------- | ---------------------------- |
| Skills library | On by default | Off by default |
| Directly in a project | Always on | Always on |
| Created from chat | Always on | Always on |
To turn a skill on or off in a project:
1. Open your Bolt project.
2. In the top center of the screen, click the **gear icon**, then click **Skills**.
3. Find the skill you want, then turn it on or off.
## Apply a skill in chat
There are two ways to apply a skill in chat:
* Select the skill by clicking the **plus icon** then pointing to **Skills** to show the available skills in your project.
* Manually type the skill name using a slash command.
You can apply one skill per message you send to Bolt.
You'll see the skill name in the chat when a skill is triggered, so you can see which skill has been applied to the current response.
### Pick from the Skills menu
1. In the chatbox, click the **plus icon**.
2. Click **Skills**.
A list appears that shows skills available in your project.
3. Click the skill name to insert it into the chatbox.
### Type the skill name
1. In the chatbox, type `/$skill-name`. For example, `/write-app-copy`.
As you type, a menu opens showing the skills available in that project.
2. Hover over a skill to see its name and description.
3. Click the skill you want to apply.
### Apply a skill to your first prompt
To use a skill in your first prompt, you have to [pick from the Skills menu](#pick-from-the-skills-menu) in the chatbox on the Bolt homepage.
You can choose from any skill in your workspace, including Bolt-curated skills. The skill you choose stays turned on for the project afterward.
## Duplicate or transfer projects that use skills
When you [duplicate](/building/using-bolt/projects-files#duplicate-a-project) a project, the duplicate stays in the same workspace, so all the same skills are available.
When you [transfer](/building/using-bolt/projects-files#transfer-a-project) a project, only skills added directly to the project move with it. Workspace skills don't transfer because they belong to the workspace, not the project.
## Manage skills
Click the **three dots icon** next to a skill to access the following options:
* **Edit**: Edit the skill's name, description, or instructions.
* **Delete**: Remove the skill.
### Permissions in Team workspaces
* **Admins** can add, edit, and delete skills in their Team workspace. When a skill is deleted, it's deleted for all team members and removed from their projects.
* **Team members** can view workspace skills and turn them on or off per project. Members can't add workspace skills but can add skills in a project and edit or delete any skills they've added.
## Skills file requirements
Every skills file needs two parts:
* A frontmatter section, which needs entries for `name` and `description`
* Instructions, which define the rules or workflow you want Bolt to apply
### Frontmatter
A clear, specific `description` is important in making sure Bolt applies your skill in the right situations. Start with "Use when" and write the description to include a trigger, scope, and boundary:
* **Trigger**: The situations when Bolt should apply the skill. For example, "Use when writing or editing any text that appears in an app's interface."
* **Scope**: Specific examples when the skill applies. For example, "Covers button labels, calls to action, headings, and empty states."
* **Boundary**: Specific examples when the skill doesn't apply. This helps distinguish between similar skills and prevents Bolt from using the skill where it isn't relevant. For example, "Doesn't apply to placeholder content or sample user data like names or emails."
Combine these elements into a short paragraph that covers when Bolt should apply the skill, what it applies to, and when it doesn't apply.
The description is the main way you can control when Bolt uses a skill. If Bolt applies a skill too often, the description is probably too broad. If it never applies the skill automatically, the description is too narrow or doesn't match how you're prompting.
A frontmatter section looks like this:
```text theme={"system"}
---
name: write-app-copy
description: "Use when writing or editing any text that appears in an app's interface. Covers button labels, calls to action, headings, and empty states. Doesn't apply to placeholder content or sample user data like names or emails."
---
```
When you import a skill [from GitHub](#import-skills-from-github) or [from a file](#import-from-a-file), Bolt checks that each file has a valid frontmatter section at the top of the file, and that it follows a certain format. If your frontmatter isn't formatted correctly, you'll see an error.
| Frontmatter field | Can include | Can't include | Size limit |
| ----------------- | ----------------------------------------------------------------- | ------------------------------------------------------------------------------- | ----------------------- |
| `name` | Lowercase letters, numbers, and hyphens | Spaces, underscores, XML tags, or reserved words (like "anthropic" or "claude") | Maximum 64 characters |
| `description` | Free-form text, including spaces, full sentences, and punctuation | XML tags | Maximum 1024 characters |
If you [write the skill yourself](#write-instructions-manually), Bolt helps you observe these rules. For example, Bolt automatically changes any spaces, underscores, or capital letters you enter in the **Skill Name** field so they fit the frontmatter requirements. That's why you'll notice all skill names you write in Bolt follow the format `your-skill-name`.
### Instructions
Instructions define the rules, guidelines, and workflows you want Bolt to follow when applying your skill. Follow these tips to write an effective skill:
* **Cover one topic per skill.** Skills work best when they focus on a specific, well-defined topic. If you find yourself writing sections that feel unrelated, consider splitting them into separate skills.
* **Write in plain language.** Use short, clear sentences. Avoid jargon and unnecessary detail.
* **Use headings to separate distinct subtopics.** If your skill covers more than one aspect of a topic, headings help Bolt apply the right section to the right situation.
```text theme={"system"}
# Write app copy for your Bolt project
Read this skill before writing or editing UI copy. Apply these principles to button labels, calls to action, headings, and empty states.
## Core principle
Good UI copy is invisible. It tells users what to do, what happened, or what to expect without drawing attention to itself. When copy is unclear or inconsistent, users slow down or lose trust in the product.
## Voice and tone
- Write in second person ("you") when addressing the user.
- Use present tense.
- Keep the tone friendly but not overly casual. Match the formality of the product's audience.
- Use contractions to keep copy conversational.
- Don't use jargon unless the target audience expects it.
## Buttons and calls to action
- Use verb-first labels that describe the action. Write "Save changes" not "OK."
- Be specific. Write "Delete account" not "Confirm."
- Keep labels short. Two to four words is usually enough.
- Match the label to the outcome. If clicking a button creates something, the label should say "Create," not "Submit."
## Headings and section titles
- Use sentence case. Capitalize only the first word and proper nouns.
- Write headings that describe the content in the section, not just name it. Write "Your recent orders" not "Orders."
- Keep headings short. If a heading needs more than a few words, consider whether the section is too broad.
## Empty states
- Tell users why the space is empty and what they can do about it.
- Include a call to action when there's a relevant next step.
- Keep the tone encouraging, not clinical. Write "You haven't added any products yet. Click Add product to get started" not "No products found."
## Consistency
- Use the same word for the same thing throughout the app. If a feature is called "Projects" in one place, don't call it "Work" or "Items" somewhere else.
- Use the same verb patterns for similar actions. If one action uses "Add," similar actions should use "Add" too, not "Create," "New," or "Insert."
```
## Troubleshooting
* If Bolt doesn't apply a skill automatically when you expect it to, use `/$skill-name` to trigger it manually, and see [Skills file requirements](#skills-file-requirements) for help refining the skill's description.