5 things you should know about AI Skills

When working with a coding assistant, you often repeat the same guidance: how to review a pull request, which conventions to follow, and what to check before shipping a change. Those instructions can become scattered across chats and documents. AI Skills offer a way to package useful procedures as reusable resources.

Here are five core ideas, followed by a practical .NET code-review example. Skill does not mean exactly the same thing in every product; this article focuses on instruction-and-resource packages that compatible agents can discover and use.

1. What is a Skill?

A Skill is an organized collection of instructions, criteria, examples, and sometimes supporting files or scripts for a category of tasks. It is not a guarantee of behavior. An agent must interpret and apply it.

A code-review Skill might tell the agent to inspect correctness, security, test coverage, and clarity, then report evidence tied to the affected files.

2. A Skill is not an agent

These are separate concepts:

• Model: generates reasoning and responses from the available context.
• Agent: pursues a goal using instructions and accessible tools.
• Skill: supplies reusable task-specific knowledge and procedures.
• Harness: provides execution and control mechanisms around an agent.

A Skill does not operate by itself. It relies on a compatible agent or environment to find, load, and apply it.

3. Specialization should solve a real problem

Useful software-engineering examples include:

• Reviewing ASP.NET Core endpoints for demonstrable risks.
• Preparing unit tests that match repository conventions.
• Documenting architecture decisions with a shared template.
• Checking database migrations before deployment.

Prefer a focused, testable Skill over one that claims to cover the entire development lifecycle. Combining too many responsibilities makes failures harder to diagnose.

4. Reuse still requires maintenance

A well-defined Skill reduces repeated instructions and promotes shared criteria. But frameworks, internal conventions, and security requirements change.

Before reusing a third-party Skill, inspect its source, scripts, requested capabilities, and compatibility. Do not install large collections indiscriminately or grant broad permissions merely because a Skill looks promising.

5. Structure and context loading

In systems compatible with the Agent Skills format, a common entry point is SKILL.md. It contains metadata and instructions and may be accompanied by references, examples, or scripts. Discovery and loading behavior varies by product.

skills/
└── dotnet-code-review/
    ├── SKILL.md
    └── references/
        └── review-checklist.md

Illustrative minimal Skill:

---
name: dotnet-code-review
description: Review C# and ASP.NET Core changes for correctness, security, and tests.
---

# .NET code review

1. Read the diff and relevant files first.
2. Prioritize reproducible defects over style preferences.
3. Check error handling, validation, and secret exposure.
4. Identify missing tests without claiming they ran.
5. Report each finding with file, impact, and suggested fix.

Verify metadata, placement, and activation requirements for the specific agent you use.

Diagram: a Skill in the workflow

This is a conceptual model: automatic discovery and selection are not universal behaviors.

Hands-on exercise: review a pull request

1. Create the Skill folder in a location recognized by your tool.
2. Add the SKILL.md instructions above.
3. Prepare a small C# change containing missing input validation and an incomplete test.
4. Ask the agent to review the change using the Skill and rank findings by impact.
5. Verify each finding yourself and revise the instructions if they produce false positives.
6. Repeat with another change to see whether results are more consistent.

Success criterion: findings must be specific and evidence-based. A long list is not a quality metric. The agent should disclose any check it did not actually perform.

Benefits and trade-offs

Common mistakes

Installing too many Skills. Quantity does not automatically improve results; discovery and maintenance can become harder.

Mistaking guidance for tool access. Writing “run tests” does not grant shell access or prove tests were executed.

Making every Skill generic. Critical tasks need concrete, verifiable criteria.

Trusting reviews without verification. Agent output still requires human evaluation and independent testing.

Final thoughts

Skills make operational knowledge reusable: they describe how to approach a task, while agents act within their available tools and permissions. Start with a focused Skill, test it against real examples, and refine it over time.

Next, we will look at how AI Workflows connect tasks, agents, and decisions into a complete process.