# Everyday Skill Patterns

Course: [Agent Skills](https://www.devtutorials.ai/learn/agent-skills) · Section: Skills at Scale
Source: https://www.devtutorials.ai/learn/agent-skills/scale/everyday-skill-patterns

> Five everyday skill patterns (Reviewer, Generator, Transformer, Triage and Tool-backed), how to spot them in your DevKit, and how to build a new skill by copying a pattern.

A **skill pattern** is a shape that many skills share. In this lesson, you will learn the five patterns behind everyday developer skills. You will also learn to build a new skill by copying a pattern.

Skills solve different problems.

But many of them are built the same way.

For example:

- A UI review and a security review both list findings with a fix.
- A component skill and an endpoint skill both make new code from a template.
- Release notes and a commit message both reshape a list of changes.

So you do not need to start from a blank file.

**Simple lesson:** find the pattern first. Then fill in your own rules.

### A Real-World Example

Most letters you write follow a shape.

- A thank-you note says thanks, says why, and signs off.
- A complaint says what went wrong, and asks for a fix.

You copy the shape and change the words. Skills work the same way.

Click the button and open the **Run** tab.

- **Without the skill:** a loose list of comments.
- **With `ui-review`:** fixed headings, and every finding has a fix.

**Simple lesson:** a pattern gives every reply the same useful shape.

## What You Will Learn

In this lesson, you will learn:

1. The five everyday skill patterns.
2. The Reviewer pattern.
3. The Generator pattern.
4. The Transformer and Triage patterns.
5. How any pattern can use a tool.
6. How to ship one skill end to end: build, install, test, check, scan, version and share.

**About this lesson's Skill Lab**

- This is the last hands-on lesson of the course.
- Run the Reviewer and Generator samples in the **Run** tab.
- At the end, run the full **Evals** and the full **Route** challenge.

## The Five Patterns

Most everyday skills fit one of five patterns.

The question to ask is: **what comes out?**

- **Reviewer** = checks something that exists, and lists findings with a fix.
- **Generator** = makes something new from a template, plus tests.
- **Transformer** = turns a list into a new, grouped document.
- **Triage** = reads a problem and says how bad it is, why, and what to do next.
- **Tool-backed** = any of the four above, but the first step gets real data with a tool.

Your DevKit already has an example of each:

| Pattern | What goes in | What comes out | DevKit example |
| --- | --- | --- | --- |
| **Reviewer** | Code, a screen, a diff | Findings with a location and a fix | `ui-review`, `security-review`, `pr-review` |
| **Generator** | A request and team rules | New code plus tests | `react-component`, `api-endpoint`, `test-planner` |
| **Transformer** | A list of changes | A grouped document | `release-note-helper`, `commit-writer` |
| **Triage** | A log or bug report | Severity, cause, next steps | `bug-triage` |

Watch the same request answered without and with one skill from each pattern:

Each skill gave its own fixed shape. Without it, the shape was missing.

**Simple lesson:** name the pattern by what comes out of the skill.

## Reviewer Pattern

A **Reviewer** checks something that already exists.

It may review:

- Code or a pull request.
- A screen or a design.
- A config file or a query.

Watch three different reviewers. Look at the shape, not the topic:

The checks were different. The shape was the same every time.

### The Reviewer Recipe

```markdown
## Workflow
1. Check <the most important category>.
2. Check <the next category>.
3. For each finding give the location, the problem and a fix.

## Output format
- ## Findings
- ## Fixes

## Final checks
- Every finding has a location and a fix.
```

To make a new reviewer:

- Replace each `<placeholder>` with your team's real checks.
- Put the most important check first.
- Keep the last step and the headings.

Order the checks by **impact**.

- Accessibility before visual polish.
- Injection before naming.
- Bugs before style.

The agent pays the most attention to early steps.

**Simple lesson:** a reviewer = your checks, in order, plus a fix for every finding.

## Generator Pattern

A **Generator** makes something new.

It may make:

- A component.
- An API endpoint.
- A test plan.
- A config file.

### The Generator Recipe

1. Start from a file in `templates/`.
2. Follow the team's rules, with the details in `references/`.
3. Handle the states and errors the rules ask for.
4. Always write **tests** with the code.
5. Run a validator script on the result.

Click the button and open the **Run** tab.

- **Without the skill:** a route that may break the team's naming rules.
- **With `api-endpoint`:** the team's route names, status codes and a list of tests.

**Important:** generated code still needs a review before you use it.

**Simple lesson:** a generator = template + team rules + tests + a check.

## Transformer and Triage Patterns

### Transformer

A **Transformer** reshapes a list into something more useful.

For example:

- Commits into release notes.
- Closed tickets into a sprint summary.
- A schema diff into migration notes.

Its rules are simple:

- Use every item once.
- Put each item in one group.
- Keep the headings fixed, with a place for unknowns.

DevKit examples: `release-note-helper` and `commit-writer`.

### Triage

A **Triage** skill reads a problem and says what to do next.

It may read:

- An error log.
- A failing test run.
- A bug report.

Its reply has fixed parts:

- **Summary:** what is broken.
- **Severity:** how bad it is, from a fixed list.
- **Likely cause:** with a quote from the log.
- **Next steps:** what to do now.

**Important:** the cause must quote the log, because a cause with no evidence is just a guess.

DevKit example: `bug-triage`.

**Simple lesson:** a transformer reshapes a list. A triage skill explains a problem, with evidence.

## Tool-Backed Skills

Any pattern can start with a tool.

The tool gets real data. Then the skill applies the team's rules to it.

| Pattern + tool | Example |
| --- | --- |
| Reviewer + design-file tool | Review a design against the token table before coding |
| Generator + database tool | Read the real schema, then generate the endpoint |
| Transformer + issue tracker | Release notes from the tickets closed this sprint |
| Triage + log search | Pull the last hour of errors, then triage them |

Watch a tool-backed triage skill at work:

The tool got the real log. The skill kept only the lines it could prove with a quote.

**Important:** give the tool read-only access at first. Add more only when you need it.

**Simple lesson:** a tool brings the data. The skill brings the rules.

## Ship One Skill

You have learned every step in this course.

Now put them together for **one** skill.

Watch `release-note-helper` go from a file to a shared skill:

Each step has a check. Each step comes from one lesson.

| Step | What you do | The check | Lesson |
| --- | --- | --- | --- |
| 1. Build | Write the SKILL.md from a pattern | The validator shows 0 errors | Release Note Skill |
| 2. Install | Put the folder where your tool looks | The skill shows in the list | Skill Installation |
| 3. Activation test | Try requests that should and should not fire it | Every test request passes | Skill Evaluation |
| 4. Output check | Check the reply's headings, and run the script | All headings found, script says OK | Scripts and Validators |
| 5. Security scan | Read the raw file and every script | 0 red flags | Skill Security |
| 6. Version 1.0.0 | Add an owner, a version and a changelog | The library index lists it | Maintaining and Sharing Skills |
| 7. Share | Add it to the team library | A teammate can use it | Maintaining and Sharing Skills |

**Simple lesson:** a skill is ready only when every step has passed its check.

### Your Turn

1. List the tasks you asked an agent to do in the last two weeks.
2. Keep one you do often, the same way, and can check.
3. Match it to a **pattern**, and copy that shape.
4. Take it through all seven steps above.

Run your whole DevKit:

Click each button.

- **Evals:** every skill should fire for its own requests, and stay quiet for others.
- **Route:** every request should go to the right owner.

A pattern makes a skill fast to write. It does not make it correct.

- Replace every placeholder with your team's real rules.
- Give each new skill its own tests.
- Review it before you share it.

**Simple lesson:** pick the pattern, copy the shape, then ship it through all seven checks.

## TL;DR

1. **Skill pattern** = a shape that many skills share.
2. **Reviewer** = findings with a location and a fix.
3. **Generator** = new code from a template, plus tests.
4. **Transformer** = a list turned into a grouped document.
5. **Triage** = severity, cause with evidence, and next steps.
6. **Tool-backed** = any pattern whose first step gets data with a tool.
7. To make a new skill:
   - Find the pattern by asking what comes out.
   - Copy the shape from a DevKit skill.
   - Replace the placeholders with your real rules.
8. **Ship one skill** = build, install, test activation, check output, scan for safety, version it, share it.

## Common Mistakes

| Mistake | Wrong idea | Correct idea | What goes wrong |
| --- | --- | --- | --- |
| Starting from a blank file | Every skill is new | Most skills fit a pattern | Slow to write, and the shape differs from the rest |
| Mixing patterns in one skill | One skill can review, generate and triage | One skill, one pattern | The skill fires too often and does each job badly |
| Leaving placeholders in | The copied shape is enough | Use your team's real checks | The skill checks the wrong things |
| Generator with no tests | The code looks right | Always write tests with the code | Broken code gets merged |
| Triage with no evidence | A good guess is fine | Quote the log for the cause | The team fixes the wrong thing |
| Tool with write access | More access is more useful | Start read-only | A mistake can change real data |

## Check Your Understanding

## Exercises

## What to Remember

- Most everyday skills fit five patterns: Reviewer, Generator, Transformer, Triage and Tool-backed.
- Find the pattern by asking what comes out.
- A reviewer puts the most important check first, and gives a fix for every finding.
- A generator always writes tests with the code.
- A triage skill quotes the log for its cause.
- A copied shape still needs your real rules and its own tests.

Next: **Agent Skills Reference**. It is a one-page summary of everything in this course.