Agents and skills: what is the difference?

An agent is the worker that moves a task forward. A skill is the reusable way of doing a particular kind of work.

That distinction sounds small, but it gives you a useful way to design AI workflows. When a task feels unreliable, ask two questions:

1. Does the system need to decide what to do next?
2. Does it need a repeatable method for one part of the work?

The first question points to an agent. The second points to a skill.

The short version

An agent can use one or more skills. A skill does not usually need to be an agent: it can be a playbook that a person or an agent follows.

What is an agent?

An agent is a system that receives a goal, works through a sequence of actions, and uses the results of those actions to decide what to do next.

The important part is not that it can generate text. The important part is the loop:

1. Understand the goal.
2. Inspect the available context.
3. Choose an action.
4. Use a tool or produce an intermediate result.
5. Check what happened.
6. Continue, change direction, or stop.

For example, given the goal “prepare this article for publication,” an agent might inspect the repository, find the content rules, draft the article, run the checks, notice a frontmatter error, fix it, and report what is ready.

The agent is responsible for the outcome. It has to deal with uncertainty: missing files, unexpected results, and decisions that were not fully specified in the original request.

What is a skill?

A skill is a packaged method for doing a recurring type of work well. It may contain instructions, examples, reference material, scripts, templates, or quality checks.

Think of a skill as a playbook. A good playbook answers questions such as:

• When should this method be used?
• What inputs does it need?
• Which steps should happen in which order?
• What mistakes are easy to make?
• What should the finished result look like?

For example, an “article-writing” skill might say to inspect the site’s frontmatter schema, choose one reader outcome, write a clear outline, keep examples concrete, and run the site checks before handing over the draft.

The skill gives consistency. It prevents every new task from starting with a blank page and prevents important project rules from being buried in a long general prompt.

A simple analogy

Imagine a small kitchen:

• The agent is the chef deciding what to cook and adjusting when an ingredient is missing.
• A skill is a recipe or technique, such as making fresh pasta.
• A tool is the oven, knife, or food processor that makes an action possible.

The chef can choose a recipe, adapt it, and use several tools. The recipe does not decide what dinner should be; it explains how to execute one kind of preparation.

This third distinction matters. A tool performs an action. A skill explains how to use actions together. An agent decides which actions are needed for the goal.

How they work together

Suppose you ask an AI system:

Turn these rough notes into a publishable tutorial.

The collaboration might look like this:

1. The agent identifies the outcome: a tutorial that a reader can follow.
2. It selects a writing skill because the task has a repeatable editorial method.
3. The skill supplies the outline, tone, examples, and quality checks.
4. The agent uses tools to inspect the notes and the project files.
5. It makes decisions when the notes are incomplete—for example, whether to add an assumption or flag a missing detail.
6. It checks the result and returns the draft, along with anything that still needs a human decision.

The agent supplies direction and adaptation. The skill supplies craft and consistency.

When should you create a skill?

Create a skill when a task has a repeatable shape and the quality of the result depends on remembering a particular method.

Good candidates include:

• reviewing pull requests against a project’s conventions;
• turning research notes into a standard report;
• preparing a release checklist;
• creating accessible UI components;
• checking a document or spreadsheet before delivery.

You probably do not need a skill for a one-off task with no established standard. Start with a clear request, notice what you repeat, and package that repeated method once it proves useful.

When do you need an agent?

You need agent behaviour when the work involves multiple steps, tools, or decisions that depend on what the system finds along the way.

A fixed script can be enough when every input follows the same path. An agent becomes useful when the path can branch:

• if the project contains tests, run them;
• if the content is unpublished, keep it out of the public build;
• if a required field is missing, ask for it or make the smallest safe assumption;
• if a check fails, investigate before claiming success.

The more the work depends on observations and decisions, the more valuable the agent layer becomes.

The common mistake: making one layer do everything

Two design problems show up often.

An agent with no reusable skills

The agent can be flexible, but every task starts from scratch. Results vary, project rules get forgotten, and the prompt grows until it becomes difficult to maintain.

A skill pretending to be an agent

A skill can describe a strong procedure, but it should not claim to handle every possible situation. If the work requires choosing between unknown paths, leave that decision to the agent and describe the boundaries clearly.

The cleanest division is:

• Agent: owns the goal, decisions, tools, and final outcome.
• Skill: owns a reusable method, domain knowledge, and quality bar.
• Tool: owns one concrete operation.

A small design recipe

When you create a skill, keep it practical. Write down:

1. Trigger: the kind of request that should use it.
2. Inputs: the files, context, or decisions it expects.
3. Method: the important steps and their order.
4. Quality bar: how to verify the result.
5. Boundaries: what it should not guess or do without approval.

That is enough to turn personal know-how into something an agent can reuse.

The takeaway

An agent is responsible for moving toward a goal. A skill is responsible for making a recurring kind of work repeatable.

If you are building an AI workflow, start by separating those responsibilities. Let the agent decide what needs to happen next. Give it skills for the methods you want to apply consistently. Add tools for the concrete actions.

That separation makes workflows easier to understand, easier to improve, and much easier to reuse.