AI Skill System

A prompt solves a problem once. A skill solves that whole class of problem every time, because it carries the context, the steps, and the standard with it — so the model never has to re-derive them.

#Prompt vs. skill

The default way to work with AI is a loop: send a request, read the result, edit the prompt, try again. That is fine for one-shot, low-stakes tasks. It breaks down the moment work gets real — multiple steps, clear right/wrong criteria, reuse across a team, and output you actually have to trust.

At that point you have to teach the model your context, process, and standards instead of re-typing them. A skill is exactly that: a folder — anchored by a SKILL.md file — that packages the knowledge and workflow for one kind of job. Claude learns it once and applies it repeatedly, with no re-explaining.

If prompt engineering is the ceiling on your AI capability, you have already fallen behind. The next step is a library of skills you can compose.

#The five-layer model

A complete skill spans five layers — each answering a different question:

• Intent — what are we doing? The task, the expected output, and the definition of done. Skip this and the model produces something that looks fine but misses the point.
• Knowledge — what does the model need to know? Domain rules, style guides, API docs, templates, internal standards.
• Execution — how is it done? Concrete steps plus the tools: scripts, templates, commands, scaffolds, checklists.
• Verification — is it actually right? Test cases, expected examples, anti-pattern checklists. This is where most AI systems fail — not at generating, but at checking.
• Evolution — what did we learn? Gotchas, lessons, a changelog. Every time the model trips, the skill gets smarter.

#Eight kinds of skill

Sorting skills by role keeps the library searchable and reusable. Eight buckets cover most work:

• Knowledge — reference frames and domain context (brand voice, proposal standards).
• Verification — check another task's output against criteria.
• Data — clean, analyze, and summarize datasets.
• Automation — run repeatable multi-step chores end to end.
• Scaffolding — generate the initial skeleton of a project or document.
• Review — critique and improve a draft before it ships.
• Runbooks — step-by-step operational procedures.
• Infra / CI / Delivery — deployment and release with technical guardrails.

#Four golden rules

1. One skill = one job. Resist the all-in-one mega-skill. Small, single-purpose skills are easier for the model to choose correctly and easier to maintain.
2. A skill is a folder, not a file. Give each part of the work its own place.
3. Always ship a verification step. Define the pass criteria and the failure modes up front.
4. Guide, don't micromanage. Set the goal and supply context and tools, then let the agent reason. Over-scripting every keystroke makes it brittle.

skill-name/
├── SKILL.md        # the main guide (required)
├── scripts/        # runnable code
├── references/     # supporting docs
└── assets/         # templates, images

#What a SKILL.md looks like

The guide itself stays short and structured — purpose, when to use it, inputs, output, steps, and checks:

# SKILL: write-enterprise-proposal
 
## Purpose
A clean, persuasive enterprise proposal aimed at decision-makers.
 
## Use When
- Writing a proposal for a business client.
- Standardizing the structure of an offer.
 
## Required Inputs
- Client name, context/need, audience, goals, duration.
 
## Expected Output
- A complete proposal following: context -> problem -> goals
  -> program -> method -> expected results.
 
## Verification
- All required sections present?
- Logic flows goal -> result?
- Tone matches the audience?
 
## Changelog
- v1.2: tightened the review checklist, added an example.

#Verifying output: the 4C check

A simple framework for the verification layer — ask four questions of every result:

• Correctness — is it right? Sound logic, accurate facts, correct format.
• Completeness — is anything missing? All required parts, no skipped steps.
• Context-fit — does it suit the audience, domain, and the original goal?
• Consequence — if this shipped right now, what is the biggest risk?

#The operating loop

The whole system fits in one line you can run on any task:

SCOPE -> SKILL -> EXECUTE -> VERIFY -> EVOLVE

Scope the goal and success criteria, pick or design the skill, execute it with the right context, verify against your checklist, then fold the lessons back into the skill. Each turn of the loop makes the next one cheaper and more reliable — capability that compounds instead of resetting every prompt.