Claude Code Skills for Agencies: Build /onboard-client and /generate-report in 30 Minutes

If you run an agency and you've been using Claude (Code, Desktop, Cowork — any flavor) for more than a few months, you've already noticed it: the same five-ish prompts show up over and over. The client onboarding scaffold prompt. The monthly report draft prompt. The lead-qualification one. You paste them from a Notion doc, fill in the variables, hit send.

That works. It also wastes a non-trivial slice of every senior person's week, and it doesn't compound. Each prompt lives in a doc nobody opens. New hires re-invent them. The good versions degrade as people make ad-hoc tweaks. And there's no way to actually measure whether prompt v3 is better than v2.

This is what Claude Code Skills fix. Skills are reusable, versioned, auto-discovered capability packages that Claude picks up automatically when relevant. They're not new prompt templates with a fancier wrapper — they're shareable team assets, evaluable, and (once installed) invisible to the user. You write "Onboard the new Acme account" and Claude finds the /onboard-client skill and executes it. No manual selection, no doc-hunting.

This post is the practical guide to building Skills for a marketing agency. Three concrete examples — /onboard-client, /generate-report, /qualify-lead — fully buildable in under 30 minutes each. Plus what makes a Skill description trigger reliably (the part most hand-written skills get wrong) and how to share them across your team without copy-paste.

Why Skills beat "saved prompts" (the structural difference)

If you've shrugged at Skills because "isn't it just a prompt template?" — fair instinct. It's not, and the distinction matters.

The eval-driven part is the breakthrough Anthropic shipped with the Skill Creator. You give it 10-20 example prompts that should trigger your skill, plus 10-20 that shouldn't, and it splits them 60/40 into train/test, measures trigger accuracy, generates improved descriptions, and picks the best version by test score. Most hand-written skill descriptions are too vague — "use when generating reports" — and end up firing on the wrong prompts or not firing at all. The Skill Creator fixes that for you.

If you're already thinking in MCP servers for your tool integrations, Skills are the layer above: skills compose MCP calls into named, intent-discoverable workflows.

Anatomy of a Skill

A Skill is just a folder. Usually:

onboard-client/
  SKILL.md              # YAML frontmatter + skill instructions
  templates/
    notion-project.md   # Notion page template
    welcome-email.md    # Email body template
  scripts/
    setup.sh            # Optional executable

The SKILL.md looks like:

---
name: onboard-client
description: |
  Use when a new client signs and needs the standard onboarding
  flow: Notion project page, Slack channel, kickoff calendar invite,
  welcome email. Trigger phrases include "onboard [client]",
  "new client setup", "kickoff [client]".
---

# Onboard client skill

When invoked, follow this sequence:

1. Ask for: client name, primary contact email, scope of work,
   start date (if not provided).
2. Create Notion project page using `templates/notion-project.md`.
3. Create Slack channel named `client-[slugified-name]`.
4. Schedule kickoff calendar invite for the start date.
5. Draft welcome email using `templates/welcome-email.md`.
6. Return a summary with links to everything created.

## Edge cases
- If the client already has a project page, skip step 2 and ask
  whether to update it.
- If the start date is in the past, push the kickoff to next
  business day and flag it.

That's the whole spec. Claude reads the description first (cheap), decides whether to load the full skill (expensive), then follows the instructions. If you need code (a script that queries an API, formats a Markdown table, etc.), drop it in scripts/ and reference it from the SKILL.md.

Skill 1 — /onboard-client

The first onboarding cycle was probably the moment you realized your agency had no system. Project page, contracts, kickoff scheduling, Slack channel, intro email — all manual, all easy to forget a step, every time slightly different.

What the skill does: takes a brief (client name + scope), creates the Notion project page (using your template), spawns the Slack channel, drafts the welcome email, schedules the kickoff calendar invite — in one flow, returning links to everything.

Tools it needs (via MCP): Notion MCP, Slack MCP, Google Calendar MCP, Gmail MCP. Each of those is in our recommended 12 MCP servers list.

Time to build: ~25 minutes if your Notion structure is already clean. If your Notion is chaotic, pause and read our Notion Agency OS blueprint first — the skill is only as good as the Notion structure it writes into.

Trigger phrases to seed the eval:

• "onboard the new Acme account"
• "set up [client] in the standard way"
• "new client kickoff for [name]"
• "process the signed contract for [client]"

Anti-trigger phrases (shouldn't fire):

• "remind me to onboard the new dev" (internal hire, not client)
• "client churn report for last month" (reporting, not onboarding)

Run those through the Skill Creator's train/test split and you'll get a description that fires on 90%+ of intended prompts and skips 95%+ of false positives.

Skill 2 — /generate-report

Monthly client reporting is the single highest-leverage skill an agency can build. Most agencies spend 2-4 hours per client per month on reporting — that's $200-600 of senior time, per client, that the client doesn't directly pay for.

What the skill does: pulls last month's data from your stack (GA4 for traffic, Stripe for revenue if relevant, Linear for sprint progress, ad platforms for campaign performance), composes the standard sections (executive summary, KPIs, what worked, what didn't, next-month plan), and drafts the deck or Notion page using your reporting template.

Tools it needs: Postgres MCP (or BigQuery / Snowflake), HubSpot/Salesforce MCP, Notion MCP, your ad-platform MCPs (Meta, Google Ads), and your existing n8n workflow library for the formatting steps.

The honest constraint: the skill drafts. It doesn't ship the report. The senior account lead still reviews, adds qualitative context, and approves before sending. That's not a bug — clients can tell when reports are 100% AI-generated within 30 seconds. The win is going from "4 hours of pulling + formatting + drafting" to "45 minutes of review + qualitative layer."

Trigger phrases:

• "draft the May report for Acme"
• "monthly report for [client]"
• "pull together the campaign data for [client] May"

What we learned the hard way: add a --period parameter explicitly in the skill instructions, or Claude will sometimes assume "last month" when you meant "last 30 days" or vice versa. Subtle, but reports are sensitive.

Skill 3 — /qualify-lead

You get 30-200 inbound emails a week. Most aren't leads. Some are. Some are leads but not your ICP. Qualifying them is repetitive work that's easy to skip on a busy day, which means real leads slip through.

What the skill does: reads the inbound email, enriches the sender (company size, industry, recent news), scores it against your ICP (you provide the ICP definition once, the skill applies it), and drafts the response — "yes, let's chat" / "not a fit, here's a referral" / "need more info, here's what I need."

Tools it needs: Gmail MCP, an enrichment provider (Apollo / Clearbit / Hunter via HTTP), your CRM MCP, and ideally a few n8n workflows for the scoring math.

Where it shines: overnight triage. The skill runs against your inbox at 7am, sorts everything into a triage Notion page, and by the time you open your email at 9 you have a prioritized list with drafts ready to send.

Where you keep the human-in-the-loop: the skill drafts but does not send. "Send as me" actions are explicit, not automatic. The cost of one bad auto-reply is way higher than the cost of pressing enter on 50 good drafts.

The Skill Creator workflow

Anthropic ships the Skill Creator pre-installed in Claude Desktop and Claude Cowork. For Claude Code, install it first (it's an Agent Skill on the platform).

The workflow once you have it:

1. Write a v0 description based on your intuition (3-5 sentences).
2. Collect 15-30 trigger prompts from your team Slack: search recent messages where someone asked for the kind of thing this skill should do. Real prompts beat hypothetical ones.
3. Collect 15-30 anti-trigger prompts: things that sound similar but shouldn't fire (most agencies underweight this and end up with over-eager skills).
4. Feed all of them into Skill Creator. It splits 60/40, generates 3-5 improved description variants, runs each against the test set, returns scores.
5. Pick the highest-scoring variant. Sometimes the v0 you wrote wins. More often something subtly different wins by 10-20 points.
6. Ship. Commit to your repo, version it semver-style, link the spec in your team docs.

Two practical notes from doing this on a few skills:

• Skill descriptions decay. What triggers correctly today drifts as your team's vocabulary shifts. Re-run the eval every quarter on fresh prompts. 30 minutes well spent.
• Don't pack too much into one skill. If /onboard-client is doing both initial setup AND 30-day check-ins, split it. Smaller skills compose better, debug faster, and trigger more reliably.

How to share skills across your team

Two patterns work. Pick based on your team size.

Small team (1-5 people): single Git repo

Create agency-skills/ in your main internal repo. One folder per skill. Each person points their Claude config at this folder. git pull = latest skills. The Skill Creator runs locally for anyone who wants to iterate.

Medium team (5-30 people): skills registry + CI

Same repo, plus a CI job that runs eval on every PR — "does this skill still trigger correctly?" — and blocks merging if trigger rate drops below 85%. Plus a /skills page in your internal docs that auto-generates from the folder structure. Plus quarterly review meetings where the team flags skills that are firing wrong.

Either way, treat skills as real software. Version them. Test them. Deprecate them when they stop earning their keep.

The honest limits (where Skills don't help)

Skills are a great fit for repeatable, intent-discoverable work. They're a bad fit for:

• One-off creative work. If you're going to use a prompt twice in your career, don't skill-ify it. The packaging overhead isn't worth it.
• Work that requires deep specific context. Skills are good at structure, less good at "write me a strategic memo for [unique client situation X]". That stays human-driven.
• Anything where wrong output is expensive. Auto-trigger means sometimes Claude picks the wrong skill. If the cost of a wrong skill firing is "slightly off draft" — fine. If it's "client invoice sent twice" — not fine. Gate financial / external-facing actions behind explicit invocation.

What to build first

Pick the most-repeated prompt in your team's last 30 days of Slack. The one where you'd answer "yeah, we get that question every week." Build that as your first skill. The Skill Creator workflow will take you ~30 minutes end to end. Ship it. Use it for two weeks. Measure: how many times did it fire correctly vs how many times did you have to fall back to manual?

By week three you'll have a feel for what makes a good skill candidate, and the next four will go faster.

If you want the operating infrastructure that turns skills into real agency leverage — Notion structure to write into, n8n workflows to call, MCP servers to compose against — that's what we ship in the DigiTools bundle. The Agency tier includes the resale rights so the skills you build on top become billable deliverables to your clients, not just internal time-savers.

And if you haven't read it yet, the prerequisite layer for any of this is the 12 MCP servers that change agency work — Skills are the orchestration layer, MCP is the connectivity layer, and you need both.