Key takeaway: SOPs fail when they live in Notion docs nobody reopens — encoding them as Claude Code skills turns process documentation into executable, testable, version-controlled automation that runs the same way every time.
Every studio has the same problem with SOPs. Someone writes a beautiful Notion doc. Everyone nods in the all-hands. Nobody opens it again. Six months later a new team member does the intake call the old way, half the checklist gets skipped, and the audit deliverable looks different depending on who ran it.
The fix isn't another Notion page. Your SOPs are a skill waiting to be encoded.
What a skill actually is
A Claude Skill is a portable folder. Inside it: a description of when to use it, a system prompt, some specific sub-prompts for the steps, optional scripts for the parts that shouldn't be LLM calls at all. You drop the folder in, the agent picks it up, and suddenly a process that used to live in one senior's head runs the same way every time.
That's it. No platform, no subscription, no rebuild. A folder with a few markdown and prompt files.
The important shift is conceptual. A prompt is a sentence you type. A skill is a process you've encoded. You don't re-explain the rules every time you want to run the audit — you invoke the skill and the rules come with it.
When to build a skill vs. when a prompt is fine
Not every repeated task needs a skill. Here's the rule we use.
If the task is one message long and you rewrite it slightly every time, it's a prompt. Save it in a snippets file and move on.
If the task is multi-step, has conditional branches, requires consistent output structure, and more than one person at the studio runs it — that's a skill. Intake, audit, brand workshop prep, client handoff, onboarding, retrospective. These are the obvious candidates.
The tell that you need a skill: when two team members run the "same" process and produce noticeably different deliverables. That's not a people problem. That's missing encoding.
We already built one by accident
The AI Business Analyst is, structurally, a skill. We didn't call it that at the time. But look at the file layout:
prompts/
systemBase.js universal rules + snapshot context
businessModel.js one agent's prompt
competitor.js another agent's prompt
digitalPresence.js another
checklist.js another
assembler.js synthesis stepThat's not a pile of prompts. That's an audit skill, almost packaged. The systemBase.js file is the skill's operating rules. Each agent prompt is a named step. The pipeline code glues them together. Swap the pipeline code for a skill manifest and you have a portable artifact.
We haven't done the final packaging yet. The pattern is already there. Anyone who has built a multi-agent tool is two hours of refactoring away from a real skill.
What a Cinnaboner skill looks like
Here's the shape we use for internal skills. Minimal, opinionated, boring on purpose.
cinnaboner-audit-skill/
SKILL.md what this is, when to invoke, example outputs
system.md senior-auditor voice + hard rules
prompts/
01-intake.md questions to ask before the audit starts
02-scan.md what to look at, in what order
03-findings.md how to structure observations
04-prioritize.md ICE scoring rubric
05-deliverable.md output template
scripts/
scrape.js deterministic data collection
pagespeed.js performance signals
examples/
enurgen-audit.md reference-quality outputThe SKILL.md file at the top is the only bit anyone needs to read to know when to use it. The system.md defines voice — senior, direct, specific numbers over vague claims. The prompts/ folder is the actual SOP, one file per step. The scripts/ folder exists because some parts of an audit shouldn't be LLM work at all. And the examples/ folder is what keeps quality from drifting — every new run has a gold standard to match.
Note what isn't in there. No prose explaining why audits matter. No "in today's fast-moving agency environment" preamble. Nobody reads those. The skill is for execution, not persuasion.
Got an SOP nobody runs?
We'll turn it into a skill your whole team invokes the same way every time.
Our skill library
Four skills we run internally, as of today.
Intake. The conversation that turns "hi, we might need a website" into a structured brief. Covers business context, goals, constraints, decision-makers, timeline, budget range, and risks. The skill enforces one question at a time — the same rule chatbot-api.php enforces on the public site. Output is a one-page brief we can quote against.
Audit. The AI Business Analyst, essentially. Grounded scrape + LLM synthesis, producing Lean Canvas, competitor view, digital presence scores, and a 50-item prioritized action list. Used pre-proposal to ground our pitch in the client's actual reality.
PRD. Turning a scoped project into a Product Requirements Doc. Feature list, user stories, acceptance criteria, tech constraints, open questions. The skill's job is to ensure nothing the designer or developer needs to know is missing before kickoff.
Handoff. End-of-project. Produces the client-facing package: what was delivered, credentials, ongoing maintenance recommendations, the first thirty days of their own backlog. This one saves us the most time because handoffs used to be bespoke every time.
Between these four, we've cut the amount of ad-hoc writing a senior does by at least a third. Every one of them started as a Notion SOP nobody read.
A worked example: the audit skill in practice
Client comes in. We have a discovery call. Afterwards, the project lead invokes the audit skill with the client's URL. The skill's 01-intake.md prompt asks any missing context questions. 02-scan.md kicks off the scrape and PageSpeed calls — deterministic, not LLM. 03-findings.md synthesizes what the scan found into a senior-auditor narrative. 04-prioritize.md applies the ICE rubric. 05-deliverable.md formats the final document using the client's own language.
Total time: about 90 seconds of compute, 10 minutes of senior review. The senior's job shifts from "write the audit" to "check the audit and add the judgment calls a model can't make". That's the point. The skill doesn't replace the senior. It removes the mechanical work so the senior's time goes to the parts where judgment actually matters.
And every client gets the same structure, the same rigor, the same baseline. Because the skill is the SOP — and this time, someone's actually running it.
Stop writing SOPs. Encode them.
A Notion page about your process is a museum exhibit. A skill is the process, executable.
If you run a studio and you have three processes you run every single week, you already have three skills waiting to be packaged. The barrier isn't tooling — it's sitting down and writing the folder.
Pick the one that hurts the most when a new person runs it wrong. Start there.
Your process is worth encoding.
We package studio SOPs into Claude skills so quality stops drifting. Talk to us.
