Claude Code skill folders for marketing workflows
Not a single SKILL.md. A full folder — scripts, gates, reference and data — built native to Claude Code's primitives instead of the generic lowest common denominator.
Claude Code keeps shipping primitives — hooks, subagents, workflows, MCP. A folder built native to them makes your team power users of the harness. One built to the common denominator makes them people with a folder of instructions.
The problem with a prompt
It worked on Tuesday. On Thursday it invented a number.
Most marketing teams have already found the ceiling. The prompt is good, the agent is capable, and the output is still different every time — because the same work is being re-derived from scratch on every run, including the parts that were never a matter of opinion.
It drifts
Nothing pins the output down. Two runs of the same brief produce two different shapes, and you find out downstream.
It re-derives
The agent recounts, refetches and reformats every time — slowly, expensively, and with a fresh chance to be wrong.
It forgets
Last month’s correction lived in a chat thread. Nothing carried it forward, so you will be making it again.
Three levels, and almost everyone stops at one
A file, a folder, and a folder that uses the harness
Every Agent Skill is a folder with a SKILL.md in it. What separates a workflow you can trust from one you have to babysit is how much of that folder is anything more than prose.
A single SKILL.md
Instructions in a file. Better than a prompt in a doc — and that is where most stop.
- Tells the agent what to do
- Re-derives every number, every run
- Drifts as the file grows
- Nothing stops a skipped step
A full skill folder
The deterministic work becomes code. The prose becomes a router that points at it.
- Same input, same output, every time
- Loads only what the job needs
- Reviewable in a pull request
- Still limited to what every harness shares
A Claude Code-native folder
The folder stops being a document the agent reads and becomes a system the harness runs.
- Gates the agent cannot skip
- Parallel subagents, isolated context
- Wired into your real systems
- Installed org-wide as a plugin
Anatomy
What we actually hand you
Here is a monthly competitor sweep as a skill folder. Note how little of it is instructions — the prose exists to route, and the work lives in files that behave the same way every time they run.
competitor-content-sweep/One workflow. One folder. Versioned in Git.├── SKILL.mdThe router — when to fire, the six steps, where the gates are. Deliberately short.├── scripts/Everything deterministic. Written once, runs identically forever.│ ├── fetch-feeds.mjsPulls every tracked competitor. No judgement involved.│ ├── diff-since-last.mjsWhat actually changed since the last run.│ └── build-report.mjsAssembles the deck and computes every number in it.├── reference/Deep context, loaded only when the step needs it.│ ├── scoring-rubric.mdWhat makes a competitor move worth flagging.│ └── house-style.mdHow a finding gets written up in your voice.├── data/The source of truth. Changing the tracked set is a data edit, not a rewrite.│ ├── competitors.jsonWho we watch.│ └── last-run.jsonState, so the next run knows what is new.└── hooks/Gates the harness enforces. The agent cannot talk its way past these. └── pre-publish.shBrand check plus a human approval before anything leaves the building.The method
We sort every step into one of three piles
This is the entire engineering discipline behind a folder that holds up. Most of what teams currently leave to the model belongs in the middle column — and moving it there is what makes the workflow cheap, fast and repeatable at the same time.
Agent judgement
Needs a decision
- Which competitor move actually matters
- How to frame the finding for your team
- What to recommend doing about it
A script
Same input, same output
- Fetching every tracked feed
- Diffing against the last run
- Counting, sorting, formatting
- Assembling and writing the deck
A gate
Must not be skipped
- Brand-voice check before publish
- Named human approves the send
- Nothing ships without both
Why it is cheaper to run
Structure is what makes it token-efficient
A folder is not cheaper because it is smaller. It is cheaper because almost none of it is loaded at any given moment — and the largest part is never loaded at all.
That last point is the one people miss. A script can do an enormous amount of work without the agent ever reading it, so the folder can grow indefinitely without the running cost growing with it.
The descriptionAlways loadedHow the agent knows this folder exists at all. Kept deliberately tiny, because you pay for it every single session.
SKILL.mdWhen the skill firesThe router. It costs nothing until the work actually starts — which is why it must point at things rather than contain them.
reference/Only the file the step needsDeep context can be enormous, because none of it loads until a step reaches for it.
scripts/Never read — executedThe script body never enters the context window. The agent runs it and gets back an answer, so the work can be arbitrarily large and the cost stays flat.
The standing audit
We keep asking which tokens were doing real thinking
This is not a one-off cleanup at build time. We look at where a run actually spends its tokens and put every judgement step to the same question — did this need a language model, or was it a rule wearing a costume?
Look at where the tokens went
Which steps consumed the context, and what were they doing while they consumed it.
Ask if it was really judgement
Counting, sorting, deduping, formatting, threshold checks and lookups all look like reasoning in a transcript. None of them are.
Port it, and the cost falls
The same work moves into a script. The agent now pays for a call and a result instead of reasoning its way there — and it gets the same answer every time.
The discipline cuts both ways. Some steps genuinely need semantic judgement — reading a competitor's positioning, deciding what matters, writing something a person will actually read. Forcing those into rules produces a workflow that is cheap and useless. Knowing which is which is the actual skill, and it is why we audit rather than assume.
Why Claude Code specifically
We build against the harness, not around it
Claude Code is not a static target. It keeps shipping primitives — the hook surface alone now spans the session, the turn, every tool call, subagents, config and MCP — and each one is a new way to make a workflow more reliable or cheaper to run.
A folder written to the common denominator can use none of them. Building native is what turns your team into power users of the harness rather than people who happen to have a folder of instructions.
Hooks
The gate. A handler runs before the tool does and returns a decision — and the harness honours it, not the model. See below.
Subagents
Fan the work out into isolated contexts — twelve competitors researched in parallel, none of them cluttering the main thread, each resumable so a long sweep survives being interrupted.
Workflows
A multi-step fan-out written once and committed, instead of re-improvised each run. It has a dry run, so you can price and inspect a job before it spends anything.
Slash commands
The entire workflow behind one word. Anyone on the team types /competitor-sweep and gets the same run you would.
MCP connections
The folder reaches your actual systems — the warehouse, GA4, the CMS, Slack — instead of asking someone to paste an export.
CLAUDE.md + scoped rules
Context that loads exactly when the work touches the thing it governs, and stays out of the way the rest of the time.
We track what Claude Code ships, and fold it in
When a new primitive lands that makes part of your workflow more reliable or cheaper to run, that is a change to your folder — not a rewrite, and not something you have to notice yourself. Staying current with the harness is the ongoing half of the engagement.
The gate, precisely
“Never publish without a brand check” stops being an instruction
Written in a prompt, that sentence is a request the model can misread, forget, or reason its way around under pressure. Written as a hook, it is enforced by Claude Code itself. The difference matters most on exactly the runs where it is least convenient.
The agent decides to act
It has drafted the post and moves to publish it — a tool call, like any other.
PreToolUse fires first
Before the tool runs, your handler receives the call and inspects it. This is your code, in the folder, in Git.
It returns a decision
Brand check fails, or the named approver has not signed off? The handler denies it.
The harness honours it
The call never executes — regardless of what the model wanted. A denial cannot be overridden by the agent deciding it knows better.
This is the concrete reason a marketing lead can hand a workflow to an agent and sleep. The steps that must not be skipped are not in the prompt at all — they are in the folder, in your repository, enforced by the tool.
It improves, and the improvement sticks
Every correction becomes a commit
This is the difference between a folder and a prompt library. When you correct a prompt, the fix lives in a chat and dies there. When you correct a folder, the fix is a file change in Git — so the workflow gets harder to break every month instead of quietly rotting.
Run
The workflow does the job.
Observe
Something surprises us — a wrong shape, a missed case, a slow step.
Fix in the folder
A script gets tightened, a rubric sharpened, a gate added.
Commit
It is now permanent, reviewed, and true for everyone on the team.
And back to the top. The folder you have in month six is measurably better than the one we handed over — because every lesson had somewhere permanent to go.
Getting it to the rest of the team
One folder, three ways to hand it to your org
A workflow only one person can run is a bottleneck with extra steps. Distribution is part of the build, not an afterthought — and it is governed by permissions you already manage.
As a Claude Code plugin
/plugin marketplace add your-org/skills/plugin install competitor-sweepA private marketplace repo you own. Access control is simply your GitHub permissions — if a teammate can clone the repo, they can install it. If they leave, they cannot.
Committed to your repo
.claude/skills/competitor-sweep/Drop it in the repo the work already happens in. Anyone who clones gets it, with no install step at all, and it versions alongside the code it serves.
Installed from GitHub
npx skills add your-org/competitor-sweepOne command, any machine. Useful for contractors and anyone outside the org who still needs to run the workflow.
Everything we build is fully optimised for the Claude Code harness. Other harnesses read the same SKILL.md standard, so a folder is not trapped — but the optimisation is what we sell, and it is Claude Code's. If you need it somewhere else, ask and we will scope it honestly.
Try it before you hire anyone
Four free plugins we run ourselves
These are not demos. They are folders we use in our own work, published free, and they show the structure we are describing on this page better than any explanation does. Read the scripts. That is the point.
add the marketplace once
/plugin marketplace add chirag2653/public-claude-code-plugins/plugin install website-to-skill-folder@public-claude-code-pluginswebsite-to-skill-folderFreeTurn any website into a folder your agent can search
Point it at a competitor, your own docs, or a partner site. It scrapes and writes ripgrep-searchable markdown, so an agent can answer questions about the whole site without ever loading the whole site.
The clearest example of the pattern: scraping is deterministic, so it is a script — and the search stays cheap because nothing loads until it is needed.
openai-image-generationFreeCreative assets from the workflow that needs them
A tested CLI around gpt-image-2 with a JSON mode and an exit-code contract, so an agent can generate an asset mid-workflow and know whether it worked.
Shows what a script boundary buys you — the agent composes one command and gets back a file path, instead of reasoning about an API.
gemini-image-generationFreeThe same job, the other provider
Every Gemini image knob exposed as a flag, driven from SKILL.md. Swap providers without touching the workflow that calls it.
Two interchangeable plugins behind one habit — which is what happens when the interface is a script, not a paragraph of instructions.
whatsapp-notifyFreeGet told when the long job finishes
A two-way WhatsApp channel via Twilio. Send text, images or screenshots out; read replies back, voice notes included. Dependency-free Node.
The piece people forget: a workflow that runs for twenty minutes needs somewhere to reach you when it is done, or needs you.
Prefer not to use the marketplace? Every one of them also installs straight from GitHub with npx skills add chirag2653/<name>.
What you get
Files, in a repo you own
No runtime we host, no licence to renew, nothing that stops working if you stop working with us.
The skill folder
In a Git repo you own, from the first commit.
Every deterministic step, as a real script
Readable, testable, and editable by someone who is not us.
Hooks for the steps that must not be skipped
Brand checks and approvals the agent cannot route around.
A Claude Code plugin and private marketplace
So the rest of the team installs it in two commands.
A CLAUDE.md dev hub
What it is, how to test it, and a dated log of why it changed.
Handover
Your team can change it without us. That is the point.
How it runs
Four phases, then it is yours
Map
We sit with the workflow as it runs today and find every step that is secretly deterministic. This is where most of the value is discovered, and it is usually more than anyone expects.
Build
The folder gets built: the router, the scripts, the reference material, the data, and the gates. You watch it take shape in a repo you own.
Run it with you
Real work, real output, side by side, until it survives contact with an actual month. Everything that surprises us gets fixed before handover.
Enhance
Every run that goes sideways becomes a commit. The folder gets harder to break over time instead of quietly rotting the way a prompt library does.
On pricing
A build engagement, then an enhancement retainer, scoped per workflow. There is no rate card, and that is deliberate: the honest price tracks how much of your workflow turns out to be deterministic, and neither of us knows that until it has been mapped. Mapping it is the first conversation, and you will get a straight number at the end of it.
Where this fits
Marketing workflows we build folders for
The boundary is the domain, not the technology. If a marketing function runs it every week and it involves both judgement and drudgery, it is a candidate.
Competitor content sweep
Track a set, diff what changed, and get a written brief on what matters.
Content production pipeline
Brief, draft, fact-check, and pass a brand gate before a human ever opens it.
Campaign reporting
Pull the numbers from the source, compute them in code, and write the narrative around them.
Content refresh at scale
Find decaying pages, decide which are worth saving, and rewrite them to house style.
Inbound triage and routing
Read what arrives, classify it, enrich it, and put it where a human will act on it.
Research and monitoring
Standing sweeps of a market, a category, or a named account, on a schedule.
Questions
The things people ask first
Do we have to be on Claude Code?
Yes, and that is the deliberate part. A folder written to run on every harness can only use what they all share, which is a file and some prose. Building native to Claude Code is what lets us use hooks, subagents, workflows and MCP connections — and that is where the reliability and the cost savings come from. Other harnesses read the same SKILL.md standard, so nothing is trapped; ask and we will scope it honestly.
What happens when Claude Code changes?
We fold it in. New primitives land regularly, and each one is a chance to make part of your workflow more reliable or cheaper to run — a hook that closes a gap, a subagent pattern that halves a sweep, a cheaper way to hold context. Tracking that so you do not have to is the ongoing half of the engagement, and it is why the folder gets better rather than ageing.
Who owns the folder?
You do, from the first commit. It lives in a repo in your organisation. There is no runtime we host, no licence to renew, and nothing that stops working if you stop working with us.
Is this not just prompts in a folder?
That is the thing we are specifically arguing against. The work is deciding which steps should never have been left to a language model — the counting, the fetching, the formatting, the gating — and turning those into code the agent runs. What remains as prose is only the part that genuinely needs judgement.
How is this different from Zapier or n8n?
Those connect systems along a fixed path, which is exactly right when the path never varies. A skill folder is for work that needs judgement in the middle — reading, weighing, writing, deciding — with the deterministic parts pinned down around it. Plenty of workflows want both, and we will tell you when a plain automation is the better answer.
What does it cost?
A build engagement, then an enhancement retainer, scoped per workflow. We do not publish a rate card because the honest price tracks how much of your workflow turns out to be deterministic — and neither of us knows that until it has been mapped. That mapping is the first conversation.
Bring us the workflow you keep redoing
The first conversation is a mapping session: we walk the workflow as it runs today and show you which parts should never have been left to a language model. You will know what a folder for it looks like before you commit to anything.
Start with one workflow