Build a campaign from a brief with a Claude Code skill

A campaign is a dozen decisions in a fixed order: who it's for, which channels, what the sequence says, which AI field to write per lead, which senders, what the Setter may say. The server's plan_campaign and write_sequence prompts already encode that order for a connected assistant. This recipe wraps them in a Claude Code skill, so a brief typed as /victoria-campaign … becomes a draft campaign that has passed the preflight and is waiting for one word from you. It never activates on its own.

Before you start

• Claude Code with the Victoria AI MCP server added and signed in:

claude mcp add --transport http victoria https://api.versionseven.ai/mcp --scope user

then /mcp inside Claude Code to complete the sign-in, choosing Read and write. Or, for a machine that shouldn't hold a sign-in, add --header "Authorization: Bearer $VICTORIA_API_KEY" with a key that has campaigns:write and accounts:read. Connect your AI covers both.

• At least one connected sender in the workspace. The skill assigns senders; it can't connect one.

The skill

Save this as .claude/skills/victoria-campaign/SKILL.md in a project (or ~/.claude/skills/victoria-campaign/SKILL.md to have it everywhere):

---
name: victoria-campaign
description: Build a Victoria AI outbound campaign from a brief, to the house messaging rules, and stop before launch. Use when asked to create, draft or set up an outbound campaign.
disable-model-invocation: true
allowed-tools: mcp__victoria
---

Build a Victoria AI campaign from this brief, then stop before activating it.

Brief: $ARGUMENTS

Work in this order, and show me each result before the next step:

1. Read the resource `victoria://guides/messaging-rules` first. Every message you write follows it.
2. Call `campaigns_list` and tell me if a campaign with a similar name or audience exists. If so, ask whether to continue.
3. From the brief, write the audience as lead-database filters (titles, seniority, locations, industries, company size) and a one-line offer. Ask me one yes-or-no question if the brief leaves the audience open; otherwise don't ask.
4. Call `sender_accounts`. If the brief names channels, use them; otherwise pick multichannel when there is an active LinkedIn sender and a mailbox, LinkedIn-only or email-only when there is one kind. For a mailbox, call `check_domain_dns` on its domain and tell me if SPF, DKIM or DMARC is missing.
5. Call `list_sequence_recipes` filtered by those channels, pick the closest example, and fetch it with `get_sequence_template`. Keep its shape (steps, delays, branches). Rewrite every message for this audience and offer. Use at most two AI variables, each named in snake_case.
6. Call `create_campaign` with the name, description and audience filters; then `update_sequence` with the sequence; then `create_personalization_field` for each AI variable, with instructions that say what to look for and a fallback that reads well on its own; then `assign_sender_accounts` with the senders from step 4.
7. If the brief mentions booking meetings or a calendar link, call `update_appointment_setter` with mode autonomous, goal book_meeting, the link, the company name, a two-line campaign description and a knowledge base of facts taken only from the brief. Leave it off otherwise.
8. Call `campaign_preflight`. For each failing check, fix what you can with the tools above and run it again. Report any check you can't fix and what I need to do in the app.
9. Stop. Print the campaign's name and id, the sequence as a numbered list with channel and delay per step, the AI fields, the senders, and the preflight result. Then ask: "Activate it?" Only if I answer yes, call `activate_campaign`; if the preflight reported warnings, show them to me and ask again before passing ack_warnings.

Never call `activate_campaign` before I've said yes in this conversation. Never add leads from the lead database unless the brief asks for it, and quote the credit cost before you do.

Then, in Claude Code:

/victoria-campaign Heads of Sales and VPs of Sales at US B2B SaaS companies with 50 to 300 employees. We sell an onboarding tool that cuts new-rep ramp time from 90 to 45 days. Multichannel. Book meetings on https://cal.com/jordan/intro.

What happens

1. The skill reads the house messaging rules from the server (the same resource the in-app Copilot reads), so it knows the sequence format, the merge fields and what a connection note may and may not say.
2. It drafts the audience and the offer, shows them, and asks at most one question.
3. It picks a Playbook example sequence that matches the channels, keeps its shape and rewrites every message for your buyers. Each tool that writes (create_campaign, update_sequence, create_personalization_field, assign_sender_accounts, update_appointment_setter) is one you approve in Claude Code as it's called, because the server marks them as writes.
4. It runs campaign_preflight, the same readiness checks as the Activate button, and fixes what the tools can fix: a blank step, a variable without a field, a sender missing. What it can't fix (a sender to connect, a DNS record, a subscription) it reports with the page in the app to do it on.
5. It stops and shows you the whole campaign. activate_campaign runs only after you say yes, and warnings get a second look before ack_warnings.

disable-model-invocation: true means the skill runs only when you type /victoria-campaign, never because Claude decided a conversation looked like a campaign brief. allowed-tools: mcp__victoria pre-approves every tool of the server added as victoria for the skill's turn, so you aren't asked about each read; Claude Code still confirms the writes, which the server marks as such. In a conversation outside the skill, @victoria:victoria://guides/messaging-rules attaches the same messaging-rules resource by hand.

Adapting it

• A house style: add a line under step 5 with your rules ("sign off as Jordan", "no exclamation marks", "always offer the teardown first"). The messaging-rules resource stays the floor.
• A fixed sender set: replace step 4 with the sender ids to use, from sender_accounts once.
• Leads in the brief: add a step after 6 that calls import_leads with a list you paste, or find_leads and add_leads_from_search for the lead database; the latter two spend credits and quote the cost first, capped at 5,000 credits in any 24 hours.
• A team: commit the skill under .claude/skills/ in a shared repo and everyone with Claude Code and the connector has the same procedure.

What to expect

• Campaigns are created as drafts; nothing sends until activation, and activation always runs the preflight.
• update_sequence replaces the whole sequence; the server validates it (step types, a conditional after every connection request, LinkedIn messages only on the connected branch, at most 40 steps) and refuses with the failing rule rather than saving a broken one.
• An AI field needs a fallback: it's what a lead gets when the model can't find anything to say. Personalization instructions has patterns that work.
• The skill uses about fifteen tool calls per campaign, well inside 120 a minute.

Next steps

• Run a weekly campaign review from Claude or ChatGPT, for the week after launch.
• Check senders and runway on a schedule with Claude Code, the same connection, unattended.
• Choosing a sequence shape for which example the skill should start from.