Skills, agents, prompts: what actually is the difference

Three words get used almost interchangeably in the AI tooling world: skill, agent, prompt. They mean different things. Mixing them up leads to bad product decisions and worse prompt tuning. Here is the taxonomy we use at Taskclan, and why we think it matters.

A skill is a slash command with a fixed system prompt. You type /debug in your editor and the tool runs your selection through a prompt that was written specifically for debugging. Nobody parameterises the prompt at call time. The prompt does not vary based on the user or the session. Same prompt, every invocation.

Skills are for a single intent. /debug debugs. /refactor refactors. /haiku turns a function into a haiku. You always know exactly what a skill will attempt, and you can predict its output shape.

The tradeoff: a skill cannot adapt to context beyond what the model reads from the surrounding code. If you want the reply to change based on WHO is asking, or the reply to hold across ten messages, a skill is the wrong shape.

An agent is a named participant with a locked personality. In our extension, @taskclan-reviewer reviews code as a staff engineer would. @taskclan-guru answers in koans. @taskclan-sensei only asks questions, never gives the answer directly until you ask three times.

The difference from a skill: an agent's system prompt applies to every turn in the conversation. Every message you send to @taskclan-reviewer gets reviewed as code. There is no way to say "review this, but also draft a commit message" without switching to a different agent.

Agents are for consistent voice across a whole conversation, not for one shot intent. The personality holds across ten messages, and users learn to invoke a specific agent when they want that behaviour.

A prompt, in the strict sense we use, is a template with placeholders. summarize takes text and a target length. extract takes text and a shape description. The template stays fixed; the values change per call.

This is the primitive most people think of when they say "prompt engineering". The template captures the reusable structure; the variables capture what changes per user or per invocation. In Achilleon we render prompts from code:

import { render } from '@taskclan/achilleon';
const filled = render('summarize', { text: article, length: '5 bullets' });

Prompts are for programmatic use. You render one from your code with specific values and hand the result to any LLM. Skills wrap a fixed prompt for interactive use in an editor; agents wrap a fixed prompt for chat conversations; prompts (the template kind) are the raw material for anything else you want to build.

Say you are building a customer support triage system.

The classifier that reads a ticket and puts it in a bucket (billing, technical, refund, general) is a prompt. You render it at call time with the ticket text as the variable. It runs unattended in a queue worker; nobody types a slash command to invoke it.

The support engineer who wants to draft a first response uses a skill. They open the ticket, run /draft, get a draft. Same fixed prompt applied to different tickets.

The senior support lead who wants a "what should we do about this angry customer" mode configures an @taskclan-escalation agent. Every message in that conversation gets treated as an escalation question; the agent keeps its consistent voice across a discussion that spans many turns.

Same underlying LLM. Three different shapes of tool. Each solves a different problem.

People conflate these because a lot of AI tools ship one shape and call it whatever is fashionable. "Agent" got hot in 2024, so suddenly every slash command got rebranded as an agent. Every parameterised template got called a "workflow" because that word sounded operational.

The taxonomy matters because the three kinds have different failure modes.

• A skill fails if the fixed prompt is wrong for the use case. Tune the prompt.
• An agent fails if the personality drifts across turns. Tighten the system prompt or shorten the context window.
• A prompt template fails if a placeholder gets a bad value at render time, or if the template does not degrade gracefully with missing optionals. Add validation at the render layer.

Three failure modes, three fixes. All three share the same underlying shape (a system prompt) but behave very differently in production. Getting the taxonomy right is the first step to fixing the right thing when something breaks.

All three live in one open registry at github.com/taskclan/achilleon. Skills under skills/, agents under agents/, prompts under prompts/. Every entry is a schema validated YAML file; the extension pulls them at build time; the npm package exposes them all typed.

If you are not building on Taskclan, the raw system prompts still work. Every entry ships as plain markdown you can paste into any AI editor's rules file. Browse the gallery at taskclan.com/skills. The taxonomy travels with you.