And now my AI agents actually follow my processes instead of me repeating myself

Most people don't need better prompts or smarter agents. They already possess everything they need in their SOPs. An AI agent skill is just an SOP rewritten so a machine can execute it without human interpretation. Once I figured that out, everything clicked.

I think of this as SOP-to-Skill Translation. You're not designing agents. You're making your existing processes executable.

A Skill Is Just A Folder

An AI agent skill is literally just a folder. Inside that folder is one file called SKILL.md plus whatever else the process requires. Reference documents, examples, templates, perhaps some scripts. The agent reads the skill name and description when it initializes. When I provide a task that matches the skill's intent, it loads the complete instructions and follows them. Think of it as an executable SOP. Not documentation that sits idle. Actual behavior.

I've used this pattern with agents that can load files from disk, including Claude Code, Claude API, and OpenAI Codex. The SKILL.md structure follows the open Agent Skills standard, so it works across different agent platforms. This assumes an agent setup that can read files or folders as part of its context. If your agent can load instructions from disk, this pattern works.

Here's what a typical skill folder structure looks like:

podcast-qc/
  SKILL.md
  checklist.md
  templates/
  scripts/

Every SKILL.md requires YAML frontmatter with at least a name and description:

---
name: podcast-qc
description: Quality check podcast episodes for audio issues, missing sponsor reads, and format compliance. Use when reviewing podcast content before publication.
---

Podcast QC
[Instructions follow here]

The name must be 64 characters or less, lowercase letters, numbers, and hyphens only. The description should explain both what the skill does and when to use it, maximum 1024 characters.

How To Turn An SOP Into A Skill

Step 1: Start with one real SOP. Select something mundane and repeatable. Not "manage social media" or something vague. Something with concrete steps like weekly podcast quality checks or daily cafe closeout. Your first skill should be something you personally execute at least weekly and mildly resent doing. Avoid vague SOPs and select workflows that already possess a checklist or clear steps.

Step 2: Rewrite it so an agent can follow it. I transformed my SOP into short imperative steps. Instead of "ask John for approval" I wrote "prepare a draft message for John." Instead of "listen carefully for issues" I wrote "analyze transcript and flag likely problems: excessive filler words, factual contradictions, missing sponsor reads, tone shifts, awkward transitions."

Here's another example. SOP says "Review for clarity and tone." Skill version says "Scan the output for unclear sentences, passive voice, and tone mismatches. Flag specific lines and suggest edits."

Then I added acceptance criteria. What does "good enough" actually mean? For instance: "No more than three unflagged issues per episode" or "Every flagged issue includes timestamp or quote and suggested fix." What are the edge cases? When should it escalate to me? The more explicit I made it, the better it performed.

Step 3: Create the SKILL.md file. The structure is intentionally straightforward. A robust SKILL.md includes:

• Skill name and description in YAML frontmatter

• When to utilize the skill

• Inputs the user must provide

• Outputs the skill must produce

• Step-by-step instructions

• Constraints and assumptions

The naming matters considerably. I use phrases I'd actually articulate out loud. "Podcast QC" not "Audio Quality Assurance Workflow." The agent relies on natural language matching, so clarity trumps cleverness every time.

Step 4: Bundle the SOP materials. My SOPs always reference other materials. Checklists, brand guidelines, example outputs, templates. I place all of that in the same skill folder and link to it from SKILL.md. The agent loads it only when necessary instead of incorporating everything into context simultaneously. This keeps skills efficient and scalable.

Step 5: Add scripts only where they provide value. If part of my SOP says "calculate" or "parse" or "transform," that's where I incorporate a script. Small Python or Node helpers in a scripts folder. The agent executes them when needed and utilizes the results. Most of my skills don't require code though. They're just reasoning plus structured output.

Step 6: Test it properly. I place the folder into my skills directory and test by providing the agent the actual task without naming the skill. If the name and description are effective, it selects the skill automatically. If it doesn't trigger, I rename until it matches how I actually communicate. This component is important because you want the agent to activate the skill naturally when you describe the work, not when you remember to invoke it by name.

One important note: skills can execute code and access your files, so only use skills from trusted sources. Treat installing a skill like installing software on your computer.

What Changed For Me

Once I executed this several times, the pattern became obvious. Each SOP became one reusable skill. Each component of my business became a library of skills. My agents stopped being generic and started behaving like they actually comprehended my processes. Podcast workflows, cafe operations, booking flows, publishing pipelines. All of it became composable instead of me repeating the same prompts repeatedly.

If you already possess SOPs, you're substantially closer than you think. You're not inventing new workflows. You're just translating what you already know into a format agents can execute consistently. If you already wrote SOPs, you already completed the hard part. Turning them into skills isn't innovation. It's translation.