Reusable instruction sets that teach Bob new workflows and specialized tasks. Skills act as recipes that guide Bob through specific types of work in a consistent, repeatable manner.

Skills are reusable instruction sets that teach Bob new workflows and specialized tasks. Think of them as recipes that Bob follows to complete specific types of work in a consistent, repeatable manner.

Why use skills

Reusability: Define workflows once and use them across multiple conversations.
Consistency: Ensure Bob follows the same approach every time for specific tasks.
Specialization: Create domain-specific expertise for code reviews, testing, documentation, and more.
Team collaboration: Share standardized workflows across your team through version control.
Flexibility: Include supporting files like checklists, templates, and reference materials.

Requirements

Skills are only available in Advanced mode. This ensures Bob has access to all necessary tools to run skill-based workflows effectively.

How skills work

When you activate a skill, Bob receives the skill's instructions and gains access to any supporting files in the skill directory. Bob then follows these instructions to complete your task according to the defined workflow.

Skills load once per conversation to avoid duplicate prompts. Bob automatically determines when to activate a skill based on your request and the skill's description.

Creating a skill

Basic setup

Create a folder inside .bob/skills/ in your project root, or use ~/.bob/skills/ for global skills.

Add a SKILL.md file inside that folder.

Example structure:

SKILL.md

SKILL.md format

The SKILL.md file uses YAML front matter followed by the skill instructions:

---
name: code-review
description: Review code for bugs, security issues, and best practices
---

When reviewing code, check for:
- Security vulnerabilities
- Performance issues
- Missing error handling at API boundaries
- Unused imports and dead code

Provide a summary with severity levels for each finding.

Required fields:

name: The skill's display name used in the Bob interface
description: A clear summary that helps Bob decide when to activate this skill—skills without descriptions are ignored

Instructions section: Everything below the --- delimiter becomes the instructions Bob receives when the skill is activated.

Adding supporting files

You can include additional files alongside SKILL.md to provide reference materials, templates, checklists, or other resources. Bob can read these files automatically once the skill is activated.

Example with supporting files:

SKILL.md

checklist.md

severity-guide.md

Supporting files can include:

Checklists and templates
Reference documentation
Configuration examples
Scripts or utilities
Style guides

Skill locations

Skills can be defined at two levels:

Location	Scope	Use case
`<project>/.bob/skills/`	Project-specific	Workflows unique to this project
`~/.bob/skills/`	Global	Personal or organization-wide workflows

Priority: If both locations contain a skill with the same name, the project-level skill takes precedence.

Approving skills

By default, Bob asks for your permission before activating a skill. This gives you control over when specialized workflows are applied.

To skip the approval prompt:

Open Bob Settings.

Navigate to the Auto-Approve section.

Enable "Always allow skills".

With this setting enabled, Bob automatically activates skills when appropriate without requesting permission.

Writing effective skills

Clear descriptions

Write descriptions that clearly indicate when the skill should be used. Bob relies on these descriptions to determine skill relevance.

Good: "Review code for bugs, security issues, and best practices"

Avoid: "Code review skill"

Focused instructions

Keep the main SKILL.md file focused on the core workflow. Move detailed reference material, examples, and checklists to supporting files.

Example:

---
name: api-documentation
description: Generate API documentation following OpenAPI standards
---

Generate API documentation that includes:
- Endpoint descriptions
- Request/response schemas
- Authentication requirements
- Example requests and responses

Follow the style guide in `api-style-guide.md` and use the template in `api-template.md`.

Actionable steps

Structure instructions as clear, actionable steps that Bob can follow systematically.

Example:

---
name: feature-implementation
description: Implement new features following team standards
---

<Steps>
<Step>
Review the feature requirements.

</Step>

<Step>
Create a plan with file changes needed.

</Step>

<Step>
Implement the feature with tests.

</Step>

<Step>
Update documentation.

</Step>

<Step>
Verify all tests pass.

</Step>
</Steps>

Follow coding standards in `coding-standards.md`.

Example skills

Code review skill

---
name: security-review
description: Review code for security vulnerabilities and best practices
---

Perform a security-focused code review:

<Steps>
<Step>
Check for common vulnerabilities:
- SQL injection risks
- XSS vulnerabilities
- Authentication/authorization issues
- Sensitive data exposure

</Step>

<Step>
Review security best practices:
- Input validation
- Output encoding
- Secure configuration
- Error handling

</Step>

<Step>
Provide findings with:
- Severity level (Critical, High, Medium, Low)
- Location in code
- Recommended fix
- Reference to security standards

</Step>
</Steps>

Use the severity guide in `severity-levels.md` for classification.

Documentation skill

---
name: api-docs
description: Generate comprehensive API documentation
---

Create API documentation that includes:

<Steps>
<Step>
Overview section:
- Purpose and use cases
- Authentication requirements
- Base URL and versioning

</Step>

<Step>
For each endpoint:
- HTTP method and path
- Description and purpose
- Request parameters
- Request body schema
- Response codes and schemas
- Example requests and responses

</Step>

<Step>
Additional sections:
- Error handling
- Rate limiting
- Pagination

</Step>
</Steps>

Follow the template in `api-doc-template.md` and examples in `api-examples.md`.

Tips and best practices

Start simple: Begin with basic instructions and refine based on results.
Use supporting files: Keep SKILL.md concise by moving detailed content to companion files.
Test thoroughly: Verify skills work as expected before sharing with your team.
Version control: Include project skills in your repository for team consistency.
Clear naming: Use descriptive skill names that indicate their purpose.
Single responsibility: Create focused skills for specific tasks rather than trying to handle multiple unrelated workflows.

Custom modes - Create specialized Bob personas with specific tool access
Custom rules - Define behavioral guidelines that apply across all interactions
Advanced mode - The mode required for using skills

Skills

On this page