home / skills / open-circle / agent-skills / template

template skill

safe

This skill helps you craft and validate practical usage guidelines for agent skills, guiding activation in relevant user intents and scenarios.

npx playbooks add skill open-circle/agent-skills --skill template

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.3 KB

---
name: skill-name
description: A clear description of what this skill does and when to use it. Include keywords that help agents identify when this skill is relevant (e.g., "Use when the user asks about X, Y, or Z").
license: MIT
metadata:
  author: your-github-username
  version: "1.0"
---

# Skill Name

Brief introduction to what this skill provides.

## When to use this skill

Describe the scenarios where this skill should be activated:

- When the user asks about...
- When working with...
- When the task involves...

## Prerequisites

List any requirements or dependencies:

- Required tools or libraries
- Environment setup
- Knowledge prerequisites

## Instructions

### Step 1: Title

Detailed instructions for the first step.

```language
// Code example
```

### Step 2: Title

Detailed instructions for the second step.

## Examples

### Example 1: Basic Usage

```language
// Example code demonstrating basic usage
```

### Example 2: Advanced Usage

```language
// Example code demonstrating advanced patterns
```

## Common Patterns

Document frequently used patterns and best practices.

## Troubleshooting

### Issue 1

Description and solution.

### Issue 2

Description and solution.

## Additional Resources

- [Official Documentation](https://example.com)
- [API Reference](https://example.com/api)

Overview

This skill provides a concise, actionable template for building and documenting an agent skill. Use when you need a clear step-by-step guide for implementing features, documenting prerequisites, and troubleshooting common issues. It helps agents identify relevance by including keywords like setup, examples, troubleshooting, and patterns.

How this skill works

The skill inspects a project's requirements and produces a structured set of instructions: prerequisites, step-by-step implementation, examples, and troubleshooting tips. It outlines where to add code snippets, how to run basic and advanced examples, and common patterns to reuse. It is designed to be adapted to different languages and environments by replacing placeholder code blocks with real implementations.

When to use it

When the user asks for a step-by-step implementation guide for a new skill
When creating or improving documentation for an agent or plugin
When you need clear examples for basic and advanced usage
When troubleshooting common setup or runtime issues
When defining prerequisites and environment setup for contributors

Best practices

Keep prerequisites minimal and explicit: list tools, versions, and environment variables
Provide both basic and advanced examples to cover typical and edge-case workflows
Use short, focused code blocks and comment key operations for clarity
Document common patterns and recommended project structure to speed onboarding
Include troubleshooting steps for frequent errors and clear links to resources

Example use cases

Onboarding new contributors with a single ordered instruction set
Publishing a reproducible example that demonstrates core functionality
Creating a troubleshooting section for known runtime issues and fixes
Providing an extensible template that can be adapted to different languages or frameworks
Including a quick-start that shows how to run basic and advanced examples locally

FAQ

What should I include in prerequisites?

List required tools, minimum versions, environment variables, and any external services or credentials needed to run the examples.

How do I present code examples?

Provide minimal, runnable snippets for basic usage and a more complete example for advanced scenarios. Use comments to explain non-obvious steps.