9 best Claude skills for startups and SaaS founders (2026)

Every startup runs into the same shape of problem: seven jobs and three people. Marketing, sales, analytics, pricing, activation, brand - each is a real function, none of them get a full-time hire, and all of them still need to happen this week. The default answer is a prompt library, but prompts drift the moment a second person tries to use them, and the founder ends up re-pasting the same instructions into Claude every Monday morning.

Claude Code skills fix that at the primitive layer. A skill is a versioned SKILL.md file with a stated method - inputs it asks for, the framework it applies, and the shape of the output it returns. Same skill, same shape, every run. That means one operator can run a KPI blueprint on Tuesday, a lifecycle map on Wednesday, and a Bayesian test design on Thursday, and every output has a defensible method underneath it. That is what a startup actually needs, not a chat window.

This post picks the 9 free Claude Code skills a startup or SaaS founder should install first, and the order to run them in. The rule is the same across the list: install the audit or definition skill before the generation skill. If you skip that step, everything downstream is aimed at a guess.

What is a Claude Code skill

A Claude Code skill is a versioned SKILL.md file that Claude Code reads from a local .claude/skills/ folder. Inside the file: the inputs the skill asks for, the framework it applies, the output shape it returns, and a version stamp. That structure is the whole thing - a skill is not a plugin, not a tool call, not an API. It is a Markdown file with a stated method, loaded at Claude Code startup so it is available by name in the session.

The output shape is the reason skills work where prompts do not. When two operators run the-list-builder on their own ICP definitions, they both get a scored prospect list with evidence per lead, ranked Hot/Warm/Cold/Skip, in the same columns. Same skill, same shape, different data. Nobody negotiates what "good output" looks like every time.

For the primitive-layer explainer covering every pack, see the hub: Claude Code skills: what they are and which ones earn their install. For a role-by-role read of what a startup GTM team looks like when three people run it, see your GTM team has seven jobs and three people.

Why startups need Claude skills more than anyone else

The founder-led GTM problem is not a resourcing problem, it is a coverage problem. ICONIQ's January 2026 survey of 150+ B2B software companies found high-AI-adoption GTM teams run 43 percent leaner at the $10M-$25M revenue band. The gain is not in the sales rep's hour count - it is in the number of functions one operator can cover credibly.

That is what a stated-method skill actually delivers. A founder cannot be a lifecycle marketer, an SDR, a data analyst, a pricing lead and a CRO strategist at the same skill level - but the founder can run the-lifecycle-mapper, the-list-builder, the-kpi-blueprint, the-price-point-finder and the-hypothesis-engine in the same week, and every output has a method a specialist would recognize.

The skills we picked below answer three questions a startup keeps re-asking:

• Which growth lever is worth pulling first - and which ones are we deliberately declining?
• For the lever we picked, what is the strategic definition that everything downstream builds from?
• How do we know it is working, without hiring an analyst to build the dashboard?

Install the packs in about 30 seconds

The 9 skills below live across four packs. You install the packs you need with one command each, then restart Claude Code - skills load at startup, so a running session will not see them.

# Install the packs used in this post
npx skills add sidchaudhary/gtm-skills/skills/data-analyst
npx skills add sidchaudhary/gtm-skills/skills/sdr
npx skills add sidchaudhary/gtm-skills/skills/lifecycle-marketer
npx skills add sidchaudhary/gtm-skills/skills/experimentation-lead
npx skills add sidchaudhary/gtm-skills/skills/brand-designer

# Restart Claude Code, then confirm:
# "What skills do you have available?"

If you would rather install a single skill, append the folder name, e.g. .../skills/data-analyst/the-lever-finder. The pack install is the better default because skills reference each other inside a pack - the-lifecycle-mapper's segments feed the-flow-architect, the-list-builder's ICP feeds the-cold-opener, and so on. A partial install produces worse output than a full one.

9 best Claude skills for startups and SaaS founders

1. the-lever-finder - decide what to work on this quarter

The first-install skill for any startup. Takes your current growth state, scores candidate levers on effort, risk and reward, and returns a prioritized plan with a 70-20-10 allocation - 70 percent to the proven lever, 20 percent to the emerging one, 10 percent to the bet - plus an explicit statement of what you are declining to work on. That last part is the point. Most startups do not fail because their top lever was wrong; they fail because they tried to work on all six.

When to use: Quarterly planning, or any time the team is arguing about priorities without a numerator. Run this before you touch any of the execution skills below.

How to run:

You: "Run the-lever-finder for our SaaS."
      [context: current ARR, growth rate, team size, candidate levers]

Claude: -> current maturity read (where you actually are)
        -> each candidate lever scored on effort/risk/reward
        -> 70-20-10 allocation with the reasoning
        -> what we are deliberately declining this quarter
        -> named owner per lever

Best used with: Real numbers, not vibes. "Growth is slow" is not an input; "$800k ARR, 8 percent net new MRR, 4 percent expansion" is.

Where this skill hits its ceiling: It picks the lever; it does not build the campaign. The execution is downstream in the other skills on this list.

With Intempt: Growth levers become tracked workstreams inside the Marketing agent, so the 70-20-10 split shows up in the calendar, not just in a doc.

2. the-kpi-blueprint - one dashboard, no analyst

The skill that turns "we should probably build a dashboard" into a shipped one. Designs a KPI dashboard with an explicit formula per metric, the right visualization per question, alert thresholds you actually want paged on, and a layout wireframe. Meant for the startup that keeps opening five browser tabs on Monday morning because nobody has ever sat down and defined the ten numbers that matter.

When to use: Before you buy another BI seat. Founder-led teams do not lose to a bad dashboard tool - they lose to no dashboard at all.

How to run:

You: "Run the-kpi-blueprint for our SaaS exec dashboard."
      [context: business model, growth stage, stakeholder audience]

Claude: -> metric list with explicit formula per metric
        -> visualization form chosen from the question each answers
        -> alert thresholds with the reasoning
        -> layout wireframe (what goes above the fold)
        -> "metrics we deliberately did NOT include" with why

Best used with: A named audience and a specific question. "Exec dashboard" is a start; "exec dashboard for the Tuesday leadership meeting focused on efficiency" is what produces a usable output.

Where this skill hits its ceiling: It designs the dashboard; it does not build the SQL. If the underlying data model is messy, this is not the skill that fixes it.

With Intempt: The blueprint plugs into Intempt Analytics so the metrics wire straight to the customer profile, and alerts fire off the same events the campaigns run against.

3. the-voice-fingerprint - capture your brand voice once, use it forever

A startup's voice is the founder's voice until the day the founder stops writing every word, and that day arrives faster than anyone plans for. This skill reads real content samples you already like and extracts a checkable brand voice profile: tone dimensions with followable rules, required and banned vocabulary, sentence and paragraph patterns, and a weighted scorecard with a publish-ready threshold. Every other content skill in the pack runs better with a real voice profile to inherit from.

When to use: The moment somebody other than the founder starts writing copy. Also whenever an agency or contractor is about to write on your behalf.

How to run:

You: "Run the-voice-fingerprint on our best posts."
      [paste: 5-10 real posts / emails / decks you like]

Claude: -> tone dimensions, each with a followable rule
        -> required vocabulary (what to say)
        -> banned vocabulary (what NOT to say)
        -> sentence and paragraph patterns
        -> channel adaptations (LinkedIn vs email vs blog)
        -> weighted scorecard with a publish-ready threshold

Best used with: Real published work you are proud of, not aspirational examples. The output is only as sharp as the input.

Where this skill hits its ceiling: It captures the voice; it does not write the next post. That is what the-hook-lab, the-cold-opener and the-page-shipper are for downstream.

With Intempt: Voice profiles attach to campaigns so the Marketing agent can score generated content against a real threshold before it ships.

4. the-list-builder - your first outbound motion, without an SDR

Startups without an SDR still have to talk to customers. This skill takes your ICP and either sources a list from data you provide or from public web research, then scores every account Hot/Warm/Cold/Skip with evidence and a confidence score. It refuses to invent enrichment when the data is not there - if it can only see a company name, it says so, rather than making up a title.

When to use: When you know your ICP but not your target list. Also useful when a marketing campaign needs a segment you have not yet built.

How to run:

You: "Run the-list-builder for our ICP."
      [context: ICP definition, seed list or research constraints]

Claude: -> scored account list (Hot / Warm / Cold / Skip)
        -> evidence per lead
        -> confidence per lead
        -> what was inferred vs. observed
        -> honest gaps where enrichment is missing

Best used with: A tight ICP. "US SaaS companies" is not an ICP; "US-based Shopify+ merchants doing $2M-$20M in GMV with an email tool but no CDP" is.

Where this skill hits its ceiling: It scores; it does not send. The-cold-opener writes the message, and Intempt or an outbound tool sends it.

With Intempt: Scored lists become audience segments inside Intempt so the outbound cadence runs against the same profile every downstream campaign reads.

5. the-cold-opener - the first email, personalized to a signal

Takes a specific prospect, a named trigger signal, and your product value prop, then writes a complete cold email under 120 words that references the signal without being creepy about it. The stated method is what keeps it from sounding like every other cold email in the inbox - it has to name the signal, connect it to a specific consequence, and offer one thing worth trying.

When to use: Once the-list-builder has produced a Hot tier with real signals attached. Running this without a signal produces the same generic template everybody else is sending.

How to run:

You: "Run the-cold-opener for this Hot account."
      [context: prospect research + trigger signal + product value prop]

Claude: -> email body, under 120 words
        -> the signal named specifically
        -> the connection to consequence
        -> one thing worth trying (not a demo request)
        -> subject line variant options

Best used with: A real signal - a hire, a funding round, a public post, a stack change. "They are in SaaS" is not a signal.

Where this skill hits its ceiling: One email at a time. If you need a 5-step sequence with follow-ups and reply handling, that is the-sequence-doctor and the-reply-classifier in the SDR pack.

With Intempt: Cold openers plug into the outbound cadence and the reply gets classified back into the pipeline - the loop is closed instead of ending in a shared Google Sheet.

6. the-lifecycle-mapper - segment the base once, use it everywhere

Every downstream lifecycle decision - which nurture flow, which cross-sell, which save offer - depends on the segment definition being real. This skill builds RFM scoring calibrated against your own customer distribution rather than absolute cutoffs, plus behavioural signals, filter logic per segment, and the staleness rule that says when a segment has to be recomputed. That last rule is the one that keeps a segment definition alive for more than a quarter.

When to use: Before designing any lifecycle campaign, or when existing segments have stopped matching how people actually behave.

How to run:

You: "Run the-lifecycle-mapper on our customer base."
      [context: business model, order/session data, retention shape]

Claude: -> RFM tiers calibrated to your distribution
        -> behavioural signals per segment
        -> filter logic (SQL-ish pseudo-code)
        -> staleness rule per segment
        -> the segments deliberately NOT built (and why)

Best used with: Real customer distribution data - order counts, session counts, days since last activity. Averages are useless here; the whole point is calibrating against the shape.

Where this skill hits its ceiling: It defines segments; it does not build the journey. The-flow-architect and the-campaign-engine take over from here.

With Intempt: Segments plug into the Marketing agent as live audiences, so a customer moves between segments in real time instead of via a Sunday-night CSV.

7. the-first-mile-mapper - stop losing signups before activation

The post-signup activation path is the single most under-designed surface in most SaaS products. This skill maps what happens between signup and the aha moment - which step is the actual aha rather than a convenient proxy, and how drop-off at each step gets diagnosed. It rewrites the flow if the current one skips the aha entirely.

When to use: When signups are climbing but activation is not, or when "onboarding" has never been designed on purpose.

How to run:

You: "Run the-first-mile-mapper for our onboarding."
      [context: signup flow, named aha moment, activation rate by step]

Claude: -> step-by-step map from signup to aha
        -> drop-off diagnosis at each step
        -> what is missing before aha (product, prompt, prerequisite)
        -> redesigned flow if the current one skips aha
        -> the one metric that says activation is working

Best used with: A named aha moment. "User is happy" is not an aha; "user connects their store and imports first product" is.

Where this skill hits its ceiling: It designs the flow; the engineering team ships it. What it will not do is invent an aha for a product that has not yet found one.

With Intempt: Activation flows plug into lifecycle workflows so the aha step is a first-class event, not a hope logged in Amplitude.

8. the-price-point-finder - stop leaving money on the table

Startups underprice by default, and the tell is not what you would expect - it is the absence of price objections in your sales calls. This skill designs pricing and packaging: the value metric to charge on, tier structure, the price points themselves, and the timing and framing of an increase. It explicitly flags the case where no objections is evidence of being underpriced, which is the honest read most founders talk themselves out of.

When to use: Setting prices for the first time, restructuring plans, or deciding whether to raise. Also useful before a fundraise, because tier structure is a leading indicator of ACV.

How to run:

You: "Run the-price-point-finder for our SaaS pricing."
      [context: current tiers, usage data, customer segments, ARPU by segment]

Claude: -> value metric options ranked (seats vs usage vs outcome)
        -> tier structure (how many, what each includes)
        -> price points with reasoning
        -> increase timing (grandfathering, notice period, cohort)
        -> the "no objections = underpriced" flag if it applies

Best used with: Real usage data and ARPU by segment. Guessing what customers pay competitors is not an input; how your own usage distributes is.

Where this skill hits its ceiling: It designs the structure. Van Westendorp and conjoint studies are a separate exercise, and the skill will say so if it cannot infer willingness-to-pay from usage.

With Intempt: Pricing changes run inside the Sell workflows with grandfathering and cohort handling built in - a mistake here is a lot more expensive than a mistake in a landing page.

9. the-hypothesis-engine - test with a stopping rule written down

The core A/B testing skill in the CRO pack, and the one that matters most for a startup running its first real experiments. Designs a test with Bayesian priors and Thompson sampling, computes the sample size per variant needed to detect a specified minimum effect at your baseline conversion, and writes exit criteria before launch. That last part is why it earns its install - a stopping rule decided in advance is what separates a result you can build on from a number you talked yourself into halfway through.

When to use: After you have a specific change worth testing. Running it before you have named the change is designing a test for a guess.

How to run:

You: "Design a test for the pricing page change."
      [context: baseline CR, weekly traffic, min effect worth detecting]

Claude: -> hypothesis stated as a falsifiable claim
        -> sample size per variant
        -> how long that takes at your traffic
        -> guardrails (what must NOT get worse)
        -> exit criteria written BEFORE launch
        -> stop-early rule using Thompson sampling

Best used with: A specific change and a real baseline conversion rate. Without those inputs the sample size is a fantasy.

Where this skill hits its ceiling: If the math says 11 weeks and you do not have 11 weeks of traffic, the number itself is the useful output. Ship on judgment or pick a higher-traffic surface. Do not run the test for three weeks and read the tea leaves.

With Intempt: Test designs, guardrails and exit criteria are logged against the experiment so a stopping rule cannot be quietly renegotiated after launch.

Which skill to install first, per founder situation

The pattern across every row: the first skill is a diagnostic or definition skill, not a generation skill. Fix the input before you scale the output. A cold opener written against a bad list is a copy problem you cannot solve with copy. A journey designed against a fuzzy segment is a design problem you cannot solve with design.

Where Claude Code skills fit alongside Intempt

Skills produce strategy, definitions, and drafts. Intempt runs the send infrastructure, the identity graph, and the live campaigns. The handoff is one-directional: a skill drafts a segment, a journey, a KPI blueprint or a pricing structure, you review it, it runs inside Intempt Marketing against the shared customer profile.

This is the model a startup actually needs. The founder or the one operator you have hired sets strategy in a Claude Code session on Tuesday morning, and the execution layer runs against real customer data instead of a CSV pipeline that breaks on Sunday. When the SDR pack's cold openers run against Intempt's pipeline, and the Data Analyst pack's KPI blueprint reads from Intempt Analytics, you get the coverage of a 15-person GTM team without the payroll.

The reason this matters: startup teams lose the week to reconciliation. If the ESP thinks one thing about a customer and the CRM thinks another, someone spends Monday reconciling instead of building. A shared profile removes that job entirely.

What to install this week

• Install one pack, not five. Skills reference each other inside a pack, and a partial cross-pack install produces worse output than a full single-pack install. Start with data-analyst if you are pre-PMF, sdr if you are early outbound, lifecycle-marketer if you have retention data.
• Run the first diagnostic skill on real data, not a fake ICP. The skill only earns its install when the output changes what you would have done otherwise.
• Read the SKILL.md before you run it. The stated method is the whole point. If you do not know what framework a skill applies, you cannot tell whether the output is defensible.
• Version-bump when you fork. If you fork a skill and change the method, bump the version. Two people running "the same" skill with different methods is exactly the drift skills are supposed to prevent.

For a broader look at what an AI-native GTM stack looks like at startup stage, see the GTM tech stack in 2026 and your GTM team has seven jobs and three people. Start for free on Intempt if you would rather run the same jobs against live customer data than paste inputs by hand.