# Skill Creator

> >

- **Type:** Skill
- **Install:** `agentstack add skill-apollographql-skills-skill-creator`
- **Verified:** Pending review
- **Seller:** [apollographql](https://agentstack.voostack.com/s/apollographql)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [apollographql](https://github.com/apollographql)
- **Source:** https://github.com/apollographql/skills/tree/main/skills/skill-creator
- **Website:** https://skills.sh/apollographql/skills

## Install

```sh
agentstack add skill-apollographql-skills-skill-creator
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Skill Creator Guide

This guide helps you create effective skills for Apollo GraphQL and GraphQL development following the [Agent Skills specification](https://agentskills.io/specification).

## What is a Skill?

A skill is a directory containing instructions that extend an AI agent's capabilities with specialized knowledge, workflows, or tool integrations. Skills activate automatically when agents detect relevant tasks.

## Directory Structure

A skill requires at minimum a `SKILL.md` file:

```
skill-name/
├── SKILL.md              # Required - main instructions
├── references/           # Optional - detailed documentation
│   ├── topic-a.md
│   └── topic-b.md
├── scripts/              # Optional - executable helpers
│   └── validate.sh
├── templates/            # Optional - config/code templates
│   └── config.yaml
└── assets/               # Optional - static resources (images, schemas, data files)
```

## SKILL.md Format

### Frontmatter (Required)

```yaml
---
name: skill-name
description: >
  A clear description of what this skill does and when to use it.
  Include trigger conditions: (1) first condition, (2) second condition.
license: MIT
compatibility: Works with Claude Code and similar AI coding assistants.
metadata:
  author: your-org
  version: "1.0.0"
allowed-tools: Read Write Edit Glob Grep
---
```

### Frontmatter Fields

| Field | Required | Description |
|-------|----------|-------------|
| `name` | Yes | Lowercase, hyphens only. Must match directory name. Max 64 chars. |
| `description` | Yes | What the skill does and when to use it. Max 1024 chars. |
| `license` | No | License name (e.g., MIT, Apache-2.0). |
| `compatibility` | No | Environment requirements. Max 500 chars. |
| `metadata` | No | Key-value pairs for author, version, etc. |
| `allowed-tools` | No | Space-delimited list of pre-approved tools. Do not include `Bash(curl:*)`. |

### Name Rules

- Use lowercase letters, numbers, and hyphens only
- Do not start or end with a hyphen
- Do not use consecutive hyphens (`--`)
- Must match the parent directory name

Good: `apollo-client`, `graphql-schema`, `rover`
Bad: `Apollo-Client`, `-apollo`, `apollo--client`

### Description Best Practices

Write descriptions that help agents identify when to activate the skill:

```yaml
# Good - specific triggers and use cases
description: >
  Guide for designing GraphQL schemas following industry best practices. Use this skill when:
  (1) designing a new GraphQL schema or API,
  (2) reviewing existing schema for improvements,
  (3) deciding on type structures or nullability,
  (4) implementing pagination or error patterns.

# Bad - vague and unhelpful
description: Helps with GraphQL stuff.
```

## Body Content

The markdown body contains instructions the agent follows. Structure it for clarity:

### Recommended Sections

1. **Overview** - Brief explanation of the skill's purpose
2. **Process** - Step-by-step workflow (use checkboxes for multi-step processes)
3. **Quick Reference** - Common patterns and syntax
4. **Security** - Risks, mitigations, and validation (if the skill touches anything security-sensitive)
5. **Reference Files** - Links to detailed documentation
6. **Key Rules** - Important guidelines organized by topic
7. **Ground Rules** - Critical do's and don'ts

### Example Structure

```markdown
# Skill Title

Brief overview of what this skill helps with.

## Process

Follow this process when working on [task]:

- [ ] Step 1: Research and understand requirements
- [ ] Step 2: Implement the solution
- [ ] Step 3: Validate the result

## Quick Reference

### Common Pattern

\`\`\`graphql
type Example {
  id: ID!
  name: String
}
\`\`\`

## Security

> **Risk: [brief description of what can go wrong].**
> [What the user MUST do to prevent it.]

- ALWAYS [secure default behavior]
- NEVER [dangerous configuration] in production

## Reference Files

- [Topic A](references/topic-a.md) - Detailed guide for topic A
- [Topic B](references/topic-b.md) - Detailed guide for topic B

## Key Rules

### Category One

- Rule about this category
- Another rule

### Category Two

- Rule about this category

## Ground Rules

- ALWAYS do this important thing
- NEVER do this problematic thing
- PREFER this approach over that approach
```

## Security-Sensitive Content

When a skill generates configuration, code, or guidance that could cause security issues if misused, the skill MUST make those risks explicit and visible to the LLM. An LLM cannot infer security implications from context alone — it needs clearly labeled signals.

### When does a skill need security guidance?

If any of these apply, the skill is security-sensitive:

- Generates config that controls access to data (caching, auth, CORS, permissions)
- Handles secrets, credentials, or tokens
- Produces code that runs with elevated privileges
- Controls what data is shared, public, or exposed to users
- Configures network bindings, endpoints, or external access

### How to surface security in a skill

1. **Dedicated Security section** in SKILL.md or a reference file, labeled `## Security`. Not "Private data" or "Customization" — use the word "Security" so the LLM recognizes the category.

2. **Explicit warnings at the point of risk** — place security guidance next to the config or code that creates the risk, not in a separate file the LLM may not load:

   ```markdown
   ### Response caching scope

   > **Security: data leakage risk.** All cached data is PUBLIC by default.
   > User-specific fields MUST use `scope: PRIVATE` with a `private_id`
   > configured, or they will be shared across all users.
   ```

3. **Validation checklist items** — every security-sensitive feature must have corresponding checks in the validation checklist. Group them under a `## Security` heading.

4. **Ground rules** — add ALWAYS/NEVER rules for security-critical behavior. These are the strongest signal to the LLM.

5. **Require the data model** — if correct security configuration depends on understanding the user's data model (e.g., which fields are user-specific), the skill must instruct the LLM to ask the user before generating config. Do not let the LLM guess.

### Anti-patterns

- Describing a security-sensitive default (like "public by default") without labeling it as a security concern
- Placing security guidance only in reference files that load on demand — the SKILL.md itself must contain the key warnings
- Using soft language ("you may want to consider") for hard security requirements — use "MUST" and "NEVER"
- Assuming the LLM understands which fields in a schema are private — require explicit user input

## Progressive Disclosure

Structure skills to minimize context usage:

1. **Metadata** (~100 tokens): `name` and `description` load at startup for all skills
2. **Instructions** ( **Security: ...**`) next to config or code that creates security risks
- ALWAYS add validation checklist items for every security-sensitive feature, grouped under a `## Security` heading

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [apollographql](https://github.com/apollographql)
- **Source:** [apollographql/skills](https://github.com/apollographql/skills)
- **License:** MIT
- **Homepage:** https://skills.sh/apollographql/skills

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-apollographql-skills-skill-creator
- Seller: https://agentstack.voostack.com/s/apollographql
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.