Everyday Skill Patterns

By the Syncfusion DevTutorials team · Last updated October 22, 2026

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.

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:

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

## 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.

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.

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.

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.

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

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.