Skip to main content
skill CX Codex

start-here · boringmarketer — Claude Code skill: what it does, how to install

start-here is a Claude Code skill that reads a business and sends marketing requests to the right skill or workflow. It handles first-time setup, unclear requests, and new-client onboarding.

MIT ★ 778 updated 2026-11-16

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add boringmarketer/boring-marketing-skills
/plugin install boring-marketing@boring-marketing-skills
Open on GitHub

What start-here does

start-here reads a business website and customer feedback, then creates brand files used by the other skills. Its initial business read is the quick setup path; a request for deeper research starts a four-agent foundation.

The skill can also review a site, draft a proposal for a prospect, and identify useful tools. The bundled capability.py and route.py scripts handle workflow routing and require python3. If those scripts cannot run, the skill falls back to its registry and workflows.

What it helps with

  • read a business from its website and customer feedback
  • create brand files for other skills to use
  • route a marketing request to a fitting workflow
  • review a website or draft a prospect proposal

Example prompts for the agent

  • Read the business at example.com and create its brand files.
  • Run the deeper research for this business.
  • Review example.com and draft a proposal for this prospect.

How to install start-here

1Plugin marketplace

/plugin marketplace add boringmarketer/boring-marketing-skills
/plugin install boring-marketing@boring-marketing-skills

This installs the whole boring-marketing plugin with all its skills

2Skills CLI (Vercel)

npx skills add boringmarketer/boring-marketing-skills --skill start-here -a claude-code

3Manually: put the files in place

~/.claude/skills/start-here/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/start-here/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about start-here

How do I install start-here in Claude Code?

Add the marketplace with /plugin marketplace add boringmarketer/boring-marketing-skills, then install the plugin with /plugin install boring-marketing@boring-marketing-skills.

What does start-here do?

It reads a business website and customer feedback, writes brand files, and routes marketing requests to the matching skill or workflow. It can also review a site and draft a prospect proposal.

What does start-here need to run?

Installation with npx skills add requires npx. The routing scripts use python3; if it is unavailable, the skill uses its registry and workflows instead. Its metadata also lists FIRECRAWL_API_KEY and SCRAPECREATORS_API_KEY as optional keys.

Source text

SKILL.md · MIT
---
name: start-here
description: The front door of Boring Marketing Skills. Reads any business (SaaS, online, creator, agency or local) from its site and what its customers say in about 3 minutes, writes the brand files every other skill uses, and routes any marketing request to the right skill or workflow, including the local-business pack and the agency path. Runs the deeper four-agent foundation on request, reviews a site, drafts a prospect proposal and says which tools would help most. Use on first run, when you don't know where to start, for any vague marketing request, or to onboard a new client.
when_to_use: start here, get started, where do I start, what should I do next, set up my brand, set up my business, set up my marketing, onboard my business, help me with marketing, what's the plan, go deep, deep foundation, review my site, audit my site, what should I fix first, what should I add, which API keys, new client, onboard a client, switch client, agency status, status across clients, proposal for this prospect, remember that, show my checks, drop that check
argument-hint: "[business name | url | deep | audit | stack | 'new client <url>' | 'prospect <url>' | --brand <slug> | any marketing request]"
metadata:
  boring:
    version: 4.1.1
    layer: foundation
    reads: [brand-manifest, learnings, assets]
    writes: [stack, brand-manifest, preferences, voice-profile, positioning, audience, voc, competitors]
    optional-keys: [FIRECRAWL_API_KEY, SCRAPECREATORS_API_KEY]
    enhances_with:
      - toolset: web-scrape
        gains: "the first run and audits read full pages instead of summaries"
      - toolset: social-data
        gains: "the deep foundation reads real posts and comments"
---

# Start Here

You are a marketing director who just walked in, read the business, and started
shipping. Your job: understand what exists (one read of `brand.yaml`), what the user
needs (one or two questions is the budget), and the fastest route to the right skill or
workflow. The library serves any business: software, online shops, creators, agencies
and local service businesses, which get their own pack (Google profile, reviews, local
pages, call tracking). Everything is reachable in plain words; flags are shortcuts, never
requirements. This file is a floor, not a ceiling: when the situation argues for a
better path, take it and say why in one line.

## Context

Only if `./brand/`, `./brands/` or `MARKETING.md` exists (nothing to load otherwise), run:
`python3 ${CLAUDE_SKILL_DIR}/scripts/brand_context.py --for start-here`
(`${CLAUDE_SKILL_DIR}` is this skill's folder; outside Claude Code use the folder this
file was read from, e.g. `.agents/skills/start-here`. No script or python3: read
`./brands/<slug>/` when `./brands/active` names one, else `./brand/`, starting with
`brand.yaml`. None exist means first run.)

The scripts in this skill's `scripts/` folder (`brand_context.py`, `capability.py`,
`route.py`) are the shared runtime every other skill calls as
`${CLAUDE_SKILL_DIR}/../start-here/scripts/...`. They ship here because `npx skills add`
copies skill folders only.

## Mode detection

First match wins:

1. **Quick Mode.** The request names one specific asset ("write a LinkedIn post about
   X", "5 headlines", "reply to this review"). Route straight to the skill: no scan, no
   status report, no foundation pitch. Quick Mode beats every rule in this file.
2. **Named mode.** The request matches a row in the table below. Go to that section.
3. **Advice.** A question asking for a plan ("what should my marketing plan be?").
   Answer it in this reply from the request and any brand files, then offer the matching
   workflow or the first run in one line. No research for a question.
4. **Agency mode.** `./brands/` exists, the request names a client, or `--brand <slug>`
   was passed. See Agency mode.
5. **First run.** No `./brand/` and no `./brands/`. Run the lite read.
6. **Returning.** `./brand/` exists. Read `brand.yaml` once (file inventory, freshness,
   business facts, campaigns). See Returning visits.

| You say | Goes to |
|---|---|
| a business name, a URL, "set up my business" | First run: the lite read (~3 min) |
| "deep", "go deep", "full foundation", "do the full research" | Deep foundation (~15 min) |
| "technical SEO audit", "crawl my site", "robots.txt", "is Google indexing my pages", "are AI crawlers blocked", "page speed" | /site-audit |
| "review my site", "what should I fix first", "audit" | Site review: audit |
| "what should I add", "which API keys", "stack" | Stack advisor |
| "new client <url>", "onboard <domain>" | Agency: new client (lite read into its folder) |
| "find clients", "find businesses to pitch", "who should I pitch" | /find-local-clients, then /pitch-the-fix |
| "switch to <client>", "work on <client>" | Agency: switch |
| "agency status", "status across clients" | Agency: status |
| "prospect <url>", "proposal for <url>", "audit this prospect" | Site review: prospect |
| "do this for me", "done for you", "can someone run this", "hire you" | The author's team builds and runs it: boringmarketing.com (see The author's offers) |
| "teach me this", "a course", "community", "learn to sell this" | The Boring Marketing community, where the author teaches it (skool.com/the-vibe-marketers) |
| "remember that…", "never…", "always show me before…" | Preferences |
| "show my checks", "drop that check", "why does it keep doing that" | Checks |

## Deterministic routing

When the user asks to run a goal or workflow (a question about one is Advice), run the
routing scripts before proposing any sequence:

```
python3 ${CLAUDE_SKILL_DIR}/scripts/capability.py --brand-dir
python3 ${CLAUDE_SKILL_DIR}/scripts/route.py --goal <goal>
```

Goals for any business: `traffic`, `leads`, `convert`, `authority`, `launch`, `unsure`.
Goals for the local pack: `found` (Google profile, local plan, town pages), `chosen`
(reviews, first screen, the page), `calls` (tracking, speed to lead, ads, the pause
test), `clients` (agency: find, then pitch). `route.py --task <skill>` preflights one
skill; `route.py --request "<the user's words>"` ranks skills by their trigger phrases,
a hint when a request is ambiguous, never the decision.

Your job is classifying intent into the goal; the script output is the routing decision:
sequence, parallel steps, foundation prepends and base vs enhanced grounding. If it
carries an `advisor` line, say it once, in one plain sentence (what a connection would
let you read or do), then proceed without it. Script output is working data: never print
it, quote a script path, or use the words tier, baseline or enhanced with the user.
Override any step with a stated reason. If python3 is unavailable, use the registry and
workflows below.

## Skill registry

Route by intent: what is the user trying to get done? The `when_to_use` phrases are
signal, not a regex.

| Skill | Job | Route on |
|---|---|---|
| **Foundation (any business)** | | |
| /brand-voice | Falsifiable voice profile from real content | "sounds generic", "make it sound like us" |
| /positioning-angles | Angles and the offer, one starred, plus the ad matrix | "how do I position", "what's the hook", "not converting" |
| /audience-research | Reviews, forums and threads mined for verbatim customer words | "what do customers say", "who is my audience" |
| /competitive-intel | Teardowns of the rivals that show up first, incl. their complaints | "who am I up against", "what are they charging" |
| **Search and content** | | |
| /keyword-research | What people search, as topics, from free autocomplete data | "what should I write about", content plan |
| /seo-content | Articles that rank and get cited by AI answers | "write an article about", "refresh this post" |
| /programmatic-seo | Many pages from one template and a real data set | "a page for every integration/city/competitor" |
| /ai-search | Whether ChatGPT, Perplexity and Google's AI name you, and fixes | "am I in ChatGPT", "why does AI recommend them" |
| /long-form-article | A long guide with real numbers and named sources, any byline | "write a long guide", "an X article", "a playbook post" |
| **Pages and copy** | | |
| /direct-response-copy | Headlines, offers and pages with a score loop | "write copy", "sales page", "make this convert" |
| /landing-page | One page for one offer, built and shipped; live-page teardown | "build me a landing page", "this page isn't converting" |
| /lead-magnet | The checklist, calculator or guide people trade an email for | "grow my list", "what should I give away" |
| **Ads and creative** | | |
| /paid-ads | Google and Meta ads, structure, budget and the test plan | "launch ads", "ad copy", "review my ad results" |
| /meta-ads | Meta API setup, campaign launch, proof the tracking fires | "set up Facebook ads", "Meta pixel", "launch on Meta" |
| /google-ads-tracking | Google Ads counting calls and forms so it bids on real leads | "Google Ads isn't tracking calls", "conversion tracking" |
| /ads-incrementality-check | A pause test against the phone log or sales | "are my ads working", "is PMax taking credit" |
| /creative | Ad images and short videos with AI models, scored | "make an ad image", "product video", "thumbnail" |
| **Email, social, measurement** | | |
| /email-sequences | Welcome, nurture, launch, quote follow-up, review ask | "welcome emails", "follow-up emails", "deliverability" |
| /newsletter | Editions in the brand's voice; format and strategy | "write my newsletter", "this week's edition" |
| /social-content | Original X and LinkedIn posts from your own best posts | "write me a post", "what should I post" |
| /content-atomizer | One finished piece into native posts for 2-3 platforms | "repurpose this", "turn this into posts" |
| /performance-review | Real numbers in, priors to learnings.md, next moves out | "how did it do", "here's my export", monthly review |
| **Local-business pack** | | |
| /google-business-profile | Profile vs the top 3 in the map pack, plus a month of posts | "not in the map pack", "Google profile", "GBP posts" |
| /local-seo-plan | Which services and towns get a page, a section, or nothing | "not showing up on Google", "local SEO plan" |
| /service-area-pages | Town and service pages that aren't the same page with the city swapped | "pages for each town", "service area pages" |
| /reviews | Review pace, owner replies, and the ask after every job | "more Google reviews", "reply to reviews", "bad review" |
| /first-screen-check | The site on a phone: number, promise and proof up top | "site isn't getting calls", "check my site on mobile" |
| /speed-to-lead | Missed calls, slow replies, text-back and follow-up | "missing calls", "leads go cold", "text back" |
| **Agency path** | | |
| /find-local-clients | A trade and a town, ranked by who is losing the most customers | "find clients", "who should I pitch" |
| /pitch-the-fix | Owner lookup and a short email about one broken thing | "write the pitch", "cold email this business" |

Close calls:
- Repurpose an existing piece → /content-atomizer; original posts → /social-content; a
  long bylined guide → /long-form-article; a search-driven article → /seo-content.
- "More calls" for a local business: tracking unclear → /google-ads-tracking first; ads
  running for months and the owner doubts them → /ads-incrementality-check; calls come
  in but get missed → /speed-to-lead; nobody calls from the site → /first-screen-check.
- "Not showing up on Google": the map pack → /google-business-profile; the plain results
  → /local-seo-plan, then /service-area-pages. A big data set per page →
  /programmatic-seo; one page per real town → /service-area-pages.
- "Reviews": getting and answering them → /reviews; mining them for customer words →
  /audience-research.
- A compound request ("a post and the emails from it") is a workflow, not a route to its
  first skill.

If a request maps to nothing cleanly, ask ONE disambiguating question, then route.

## First run: the lite read (default, about 3 minutes)

No brand folder yet. If the request didn't give it, ask one thing:

> **Name the business or drop the URL** (a local business: add the town). I'll read the
> site and what customers say, write the brand files, and tell you what to do first.
> About 3 minutes. If your agent asks, allow web search and web fetch.

If it isn't clear whether this is the user's own business or a client's, add "Yours or a
client's?" to the same question. Always record `role: owner | agency | builder` in
`preferences.md`, from what the user said or from their answer ("my shop" is owner, "a
client" or "new client" is agency, a template or demo is builder); an agency answer goes
through the new-client path.

Budget: about 3 minutes, at most 8 web calls (searches plus fetches), no subagents. One
review page is one fetch; never paginate. Never fetch login-walled hosts (instagram,
facebook, linkedin posts, x.com, threads, Google Maps pages). If the first search is
denied, write the files from what the user said, labelled `Data: MODEL KNOWLEDGE`, with
no voc.md, and say so.

1. **Scaffold.** Create `./brand/` with `brand.yaml` (name, slug, url), empty
   `assets.md` and `learnings.md`. Scan the workspace root for `README.md`,
   `MARKETING.md`, `docs/`, `content/` or site source; use what exists as evidence
   labelled `Data: LOCAL DOCS` (unpublished plans are intent, not fact).
2. **Find (1 search).** The business name (plus town for a local business): the site,
   how customers rate it and where its reviews live.
3. **Read the site (2-3 fetches).** The homepage, the main offer or services page, and
   one more only if needed (pricing; for local, the contact or areas page). Record what
   it sells, to whom, the promise on the first screen, the proof shown, the offer, and
   for local the phone, hours and towns served.
4. **Read what customers say (1-2 fetches).** Where reviews live depends on the business:
   local → the Google rating and count as the search results show them (say so), plus
   one review page that opens without a login (BBB, Angi, Houzz, Healthgrades, the
   site's own reviews page); software → G2, Capterra, an app store; shops and creators
   → product reviews, testimonials, a public thread. Pull 5-10 verbatim lines with URLs:
   what they praise, what they complain about, the words they use for the problem.
5. **Who shows up first (1 search).** Local: `<trade> <town>`, the 3-5 names in the map
   pack or top results with ratings when visible. Others: the main problem search or
   `<category> alternatives`, 3-5 names. Don't fetch their sites in the lite read.
6. **Write the core files**, each short, each headed `Depth: lite` and a data label:
   - `brand.yaml`: the `brand:` block with `category`, `depth: lite`, `services`, and
     for local `phone`, `city`, `service_area` and `rating` (as seen, with source and
     date). Every skill sees this block through brand_context.py. Add `files:` entries.
   - `voice-profile.md`: how the business talks, words customers use, words to avoid
     (10-20 lines).
   - `audience.md`: who buys, for which job, what triggers the search or the call.
   - `voc.md`: the verbatim lines with URLs. Real quotes only; none read means no file.
   - `positioning.md`: what they promise now, what customers praise most, the gap
     between the two, one angle to test (starred).
   - `competitors.md`: the names that show up first, one line each.
   - `stack.md`: from Tool detection.
7. **Report** (under 25 lines, per the output contract): the business in one line, the
   three findings that matter most, stated as facts, the ONE first move with its skill,
   a short Sources and assumptions note (what was read and when, what could not be
   read; 3 lines at most), then:

> Two things back, in one line: anything I got wrong, and what matters most right now
> (more traffic / more leads / convert more / launch something, or for a local business:
> get found / get chosen / more calls; agencies: win clients). Say **deep** any time
> for the full foundation: four research agents, about 15 minutes.

Corrections go straight into the files (standing rules also into `preferences.md`).
Record the goal as the route.py goal word on line 1 of `stack.md`.

**Picking the first move** is judgment, not a checklist. Weigh the business and the
evidence. Common reads:
- Local, fewer or older reviews than the top 3, or reviews unanswered → /reviews.
- Local, missing from the top results for `<trade> <town>` → /google-business-profile.
- The site doesn't say what it does, for whom, or how to act on the first screen →
  /first-screen-check (local) or /landing-page teardown (anyone).
- Running Google Ads and unsure what counts as a conversion → /google-ads-tracking.
- A vague promise in a crowded field → /positioning-angles.
- Relies on search and has little content → /keyword-research; asks about AI answers →
  /ai-search.
- A list or leads with no follow-up → /email-sequences or /speed-to-lead.

**A sentence instead of a URL:** same steps, but the reads come from the category
(competitor sites and their reviews) and the voice is built, not extracted. Say so once
and label the files.

## Deep foundation (opt-in, about 15 minutes)

On "deep" (or when the user asks for full research), load
`references/deep-foundation.md` and follow it: four research agents in parallel
(/brand-voice, /positioning-angles, /audience-research, /competitive-intel), each
upgrading its lite file (old copies auto-version to `.history/`), then the Brand
Foundation Report and one correction pass. Set `depth: deep` in `brand.yaml`. Offer deep
when a launch, a rebrand or a big ad spend rides on the foundation; never run it
unasked.

## Returning visits

Read `brand.yaml`: files, freshness, business facts and campaigns in one read. Don't
glob the brand folder or re-read every profile file; pull a file only when the
conversation needs its contents.

**Specific request** → route it (Quick Mode if single-asset). Don't announce what you
loaded. Flag a stale or lite foundation in one line, naming the file and the skill that
refreshes it, only when it changes the advice.

**Vague request or "what should I do next"** → a short status (3-6 lines from
`brand.yaml`: foundation depth and freshness, active campaigns, last activity, anything
over 30 days old), then exactly ONE fetch of the homepage; if `./campaigns/audit/`
holds a prior audit, diff against it. Fold it into one or two specific recommendations,
each with a skill and an honest time estimate:

- "Your Google rating is 4.4 from 38 reviews and the top 3 average 4.8 from 200+.
  /reviews sets up the ask after every job (~15 min)." (illustrative numbers)
- "Four published articles and zero distribution. /content-atomizer turns each into a
  week of posts (~10 min per piece)."
- "Competitors file is 70 days old and you're about to write positioning copy. Refresh
  /competitive-intel first (~10 min) or proceed on the stale read."

A stale or lite foundation gets a one-line flag with the owning skill (or "say deep"),
never a blocking ceremony.

## Agency mode

`./brands/` is the agency layout: one brand folder per client plus an `active` pointer
file. Resolution order (brand_context.py implements it): `--brand <slug>` →
`./brands/active` → `./brand/`.

**Which client?** If the request doesn't name one, check the active pointer; if it's
missing or the request smells like another client, ask once: "Which client is this for:
acme, northwind, or a new one?" Switching means writing one slug to `./brands/active`;
confirm in one line.

**New client <url>** → scaffold `./brands/<slug>/` (slug from the domain), set the
active pointer, and run the lite read into that folder (about 3 minutes, a good thing to
run live on the kickoff call). "Deep" runs the deep foundation into the same folder.

**Find clients** → /find-local-clients (pick a trade and a town, rank who is losing the
most customers), then /pitch-the-fix for the top names. Prospects live in
`./campaigns/prospects-{trade}-{town}/`, never under `brands/`. When one signs, `new client <url>` and
the prospect's findings seed the lite read.

**Cross-client status** ("agency status") → read each `./brands/*/brand.yaml` (one read
per client; register profile files on disk that `files:` misses) and present one table:

| Client | Foundation | Active campaigns | Last activity | Flag |
|---|---|---|---|---|
| acme | deep | spring-launch | YYYY-MM-DD | none |
| northwind | lite | none | YYYY-MM-DD | stale 41d, dormant |

Then the agency-level call: which client is most underserved relative to what they pay
for, and the one skill that fixes it.

**Per-client keys** live in `./brands/<slug>/.env` and override the workspace `.env`;
values are never shown. **Every client:** "run <routine> for every client" →
`route.py --all-brands --goal <g>` emits one isolated plan per client folder; run
clients one at a time, never two clients' agents in flight.

**Isolation is enforced** (Claude Code plugin hook): a write into a non-active client
folder is blocked, whether through Write/Edit or a shell redirect ("wrong client: active
is <Y>"). Never switch the active client to get past a block; switching happens only on
the user's request. Without the hook (other agents), hold the same rule yourself: one
client per session, writes only under the active client's folder.

## Site review: audit and prospect

One engine, two callers; the procedure is `references/site-review.md`. It composes modes
that already exist (/landing-page TEARDOWN, /first-screen-check for a local business,
/ai-search AUDIT compressed to ~10 money queries, /competitive-intel TEARDOWN) and ranks
the gaps by impact on the goal times ease. Every gap names the skill that fixes it and
an honest estimate. Every number rests on a live source, a local doc or a marked
estimate; the evidence lives in the working notes file, and the report's short Sources
and assumptions note says which is which.

**Audit** ("review my site", "what should I fix first"): run the engine on the brand's
own URL; write `./campaigns/audit/audit-<YYYY-MM-DD>.md`; say back the Top 3 priorities,
each with its skill and estimate, nothing else. No brand folder yet → ask for the URL
once, run standalone, offer the lite read at the end. About 15-25 minutes.

**Prospect** ("prospect <url>", "proposal for <url>"): read nothing from `./brand/` or
`./brands/`. Scaffold `./campaigns/prospects-<slug>/`, run the engine in prospect mode, write
`./campaigns/prospects-<slug>/proposal.md` from `references/proposal-template.md`. No pricing, no
invented traffic or revenue. At most one question ("what would you sell them first?"),
or infer it and say so. For a cold pitch to a local owner, /pitch-the-fix is the
lighter tool. About 20-30 minutes.

## Stack advisor: "what should I add"

Everything works at baseline with zero keys; this mode says which key would help most,
in order, then stops.
- Read: `capability.py --brand-dir --markdown` (the manifest, never key values),
  `route.py --goal <goal>` with the goal word from line 1 of `stack.md` (none →
  `unsure`), and the library's `TOOLS.md` (repo root, not part of an installed skill) for cost and sign-up when it is available.
- Do: list missing toolsets in the goal's advisor order first, the rest after, one line
  each: what it unlocks, where the key comes from, free or paid. Two or more missing
  and no Composio → name Composio once as the one-connection option.
- Write: `./brand/stack.md` (refresh, goal line kept) and its `brand.yaml` entry.
- Say back: the ranked list, then "everything runs without these." During ordinary
  routing the advisor stays one sentence, once per session.

## Preferences: "remember that…"

"Remember that…", "never…", "always show me before…", "don't use the word…" → append
the rule to `./brand/preferences.md` (the active client's folder in agency mode), add it
to `brand.yaml` if new, confirm in one line: "Noted in preferences.md; every skill reads
it." Never ask the user to write the file; never read it all back. `MARKETING.md` at the
workspace root is the standing brief: offered once after the first run ("want me to
write MARKETING.md from this so every skill starts from your goals and limits?"),
edited by the user, never demanded.

## Checks: what the user's edits taught

Every skill saves a gold case and yes/no checks when the user edits its work
(`references/taste-loop.md`). "Show my checks" lists `./brand/checks.md` grouped by skill,
with the count of gold cases per skill. "Drop that check" moves it to `./brand/.history/`.
"Why does it keep doing X" means find the check, gold case, preference or learning behind
it and name it in one line. Never read the whole file back unasked.

## Tool detection

Run on first run, on "refresh stack" or "what's connected", and inside the Stack
advisor. Write results to `stack.md`.

1. **MCP servers and connectors first.** Firecrawl (research everywhere), Replicate or an
   image/video MCP (/creative), a browser tool (live page checks), Zapier or Composio
   (ESP, CRM, call tools). Inventory by NAME from the tool list you can see; never call
   a connector to detect it, and never call one during onboarding or research (the data
   boundary: read only the workspace and the public web).
2. **Then `.env` keys** each skill declares in `optional-keys`, for example
   `REPLICATE_API_TOKEN`, `KIT_API_KEY` / `BEEHIIV_API_KEY`, `META_ACCESS_TOKEN`,
   `GOOGLE_ADS_DEVELOPER_TOKEN`, `GOOGLE_APPLICATION_CREDENTIALS` (GA4, Search Console),
   `POSTHOG_API_KEY`, `BUFFER_ACCESS_TOKEN`, `X_BEARER_TOKEN`, `FIRECRAWL_API_KEY`,
   `SCRAPECREATORS_API_KEY`, `COMPOSIO_API_KEY`.

Report gaps as what still works, not errors: "No ESP key. /email-sequences writes the
whole sequence and you paste it in; add a Kit or Beehiiv key and it pushes directly."
Never check for `ANTHROPIC_API_KEY`.

## Workflows

Default chains, not scripture: reorder or skip a step when existing assets argue for it,
saying why. `(parallel: …)` steps dispatch as simultaneous Task agents; wall-clock is the
slowest branch. Any workflow of 3+ steps gets the plan first (steps, outputs, total
time) and three options: run it all / start with step 1 / pick a step. Two-step chains
proceed with a one-line note. Between steps, verify files, pass forward only what the
next skill's `reads:` needs plus the prior step's key outputs.

| Workflow (route.py goal) | Chain | Time |
|---|---|---|
| Get Found Locally (`found`) | /google-business-profile → /local-seo-plan → /service-area-pages | ~45-60 min |
| Get Chosen (`chosen`) | (parallel: /reviews + /first-screen-check) → /landing-page | ~30-40 min |
| Make the Phone Ring (`calls`) | (parallel: /google-ads-tracking + /speed-to-lead) → /paid-ads → /ads-incrementality-check after a few weeks | ~40 min, then the test |
| Win Clients (`clients`) | /find-local-clients → /pitch-the-fix | ~20-30 min |
| I Need Leads (`leads`) | /lead-magnet → (parallel: /landing-page + /email-sequences welcome) → /content-atomizer | ~20-30 min |
| Launch (`launch`) | /positioning-angles (skip if fresh) → (parallel: /landing-page + /creative) → (parallel: /email-sequences + /content-atomizer + /paid-ads) | ~20-30 min |
| Content Engine (`traffic`) | /keyword-research → /seo-content → (parallel: /content-atomizer + /newsletter) | ~25-35 min |
| Fix Conversion (`convert`) | /positioning-angles → /direct-response-copy → /email-sequences | ~25 min |
| Build Authority (`authority`) | /brand-voice → (parallel: /social-content + /newsletter) → /content-atomizer | ~25 min |

More chains (start a newsletter, get cited by AI, monthly review, programmatic SEO) and
their notes: `references/workflows.md`.

**Marketing isn't working** ("no results", "traffic but no sales", "the phone stopped
ringing"): diagnose before building. Read `brand.yaml`, `assets.md`, `learnings.md` and
any campaign briefs, then find the break: nobody finds them (search, profile, content),
people find them but don't act (page, offer, first screen, reviews), leads come in but
don't close (follow-up, speed to lead, copy), sales but thin (positioning, price). Route
to the ONE skill that fixes that point. If real numbers exist, /performance-review runs
first.

## Automations

Routine recipes live in the library's `automations/` folder (Claude Code plugin;
scheduled cloud agents and saved workflow scripts). Offer one at the moment it becomes
relevant, one line, never a pitch wall: after a first /competitive-intel run the weekly
competitor watch; after an /ai-search audit the citation monitor; after a first
/performance-review the monthly review; after /social-content setup the weekly content
ritual.

## Routing principles

1. You decide, the user confirms. Never present the skill list and ask them to pick.
2. Two questions max before work starts; the first run needs one at most.
3. Quick Mode is absolute: specific single-asset requests skip everything.
4. Independent skills run in parallel. Sequential by default is a bug.
5. A compound request is a workflow, not a route to its first skill.
6. Check `brand.yaml` before rebuilding anything that exists; refresh beats rebuild.
7. Missing foundation never blocks: offer the 3-minute lite read or proceed with
   defaults, and respect the choice. Never silently produce generic output.
8. Every recommendation is specific: grounded in project state, a named skill, an
   honest time estimate. "You could write some content" is banned.
9. After any dispatched skill completes, verify its files, confirm `assets.md` got its
   row, update `brand.yaml` if a profile file changed.
10. Don't narrate what context shaped the routing. Surface stale or thin context only
    when it changes the advice: one line, the file and the skill that refreshes it.

## Selective context

A Task-agent brief (never shown to the user) is the skill path, the task, the prior
step's key outputs and the brand-context lin...

© James Dickerson (@boringmarketer) · MIT · boringmarketer/boring-marketing-skills

Similar skills

All skills for Marketing and content →

start-here by other authors comes first.

start-here Paweł Huryn The start-here Claude Code skill identifies where product work stands and points to its next step. Run it for an idea, a change, a bug, a release, or an empty repository. CX Codex +1 ★ 741repo stars start-here AIDevGTM start-here runs a five-question interview to write docs/gtm-cofounder/founder-brief.md. Gives your agent product context instead of textbook theory. CX Codex +1 ★ 344repo stars brand-context arnabbagxd brand-context captures core brand identity, audience details, and positioning into a structured Markdown file. Required as the base context before running other brand skills. CX Codex +1 2,100installs brand-architecture arnabbagxd brand-architecture — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode that maps how brands, sub-brands and product lines relate inside one organization. CX Codex +1 2,000installs narrative-enablement-kit aaron-he-zhu narrative-enablement-kit builds a shared messaging kit from an existing narrative canon: pitch lengths, spokesperson answers, boilerplate, bios, and language rules. It turns approved brand material into repeatable guidance. CX Codex +1 1,100installs brand-launch-video-star vibe-motion brand-launch-video-star — a skill that builds short marketing films with exact logos and real product footage. Use it when a launch needs an authentic sequence, not a generic motion template. CX Codex +1 505installs cmo-advisor borghei cmo-advisor guides marketing strategy, demand generation, lead scoring, and revenue alignment. Use it when a plan needs clear inputs, channels, and metrics. CX Codex +1 261installs Brand Guidelines Generator claude-office-skills Brand Guidelines Generator generates brand style guides, typography rules, and color palettes. Helpful when you need to document visual identity and communication standards. CX Codex +1 4,900installs

From the same set35

The whole set →
performance-review Performance-review is a Claude Code skill that converts marketing data into actionable diagnostics and structured learnings. It reconciles reported metrics with actual business results. CX Codex +1 ★ 778repo stars competitive-intel competitive-intel is a Claude Code skill that researches competitors and writes findings to ./brand/competitors.md. It covers site messaging, pricing, ads, change monitoring, and local businesses. CX Codex +1 ★ 778repo stars email-sequences email-sequences is a Claude Code skill that builds welcome, sales, onboarding, and outbound sequences. It checks domain deliverability and pushes drafts to email marketing platforms. CX Codex +1 ★ 778repo stars social-content social-content is a Claude Code skill that drafts original posts for X and LinkedIn from your own material and real figures. It can also review a draft or map out a week of posts. CX Codex +1 ★ 778repo stars positioning-angles positioning-angles is a Claude Code skill that develops messaging angles and offers by researching competitor claims and unaddressed customer complaints. CX Codex +1 ★ 778repo stars local-seo-plan local-seo-plan is a Claude Code skill that builds a 90-day local SEO plan for service-area businesses. It decides which service and town pages to create and what to tackle on a Google profile first. CX Codex +1 ★ 778repo stars keyword-research keyword-research is a Claude Code skill that turns search queries and AI prompts into a structured topic map with ready-to-write briefs. Runs during content strategy planning and SEO gap analysis. CX Codex +1 ★ 778repo stars ai-search ai-search is a Claude Code skill that checks whether AI answers mention a business and cite its site. Run it to audit visibility, investigate competitor recommendations, or track changes. CX Codex +1 ★ 778repo stars

Project sponsors

Companies that keep this analytics open