# How to Create a Claude Skill, From SKILL.md to Team Sharing

Build a Claude skill step by step: SKILL.md, a scorecard file with its formula, a company profile, tests, versioning, and sharing, plus a free go/no-go package.

<KeyTakeaways
  items={[
    'A Claude skill is a folder with a SKILL.md file: a header that says what the skill does and when to use it, the instructions, and reference files Claude reads only when a task needs them.',
    'Put the scorecard, the formula that turns 1 to 5 scores into a percentage, the thresholds, and the deal-breaker rule in one reference file, so Claude never chooses them for you.',
    'Test a skill four ways before sharing it: trigger prompts, a tender you have already decided, the same task with the skill off, and a planted deal-breaker.',
    'Share one versioned package from one place, and rerun the same tests on every change before the team gets it.',
    "AutoRFP.ai keeps the company side of a go/no-go current: every answer it drafts comes from approved content and shows its source, and through AutoRFP.ai's MCP connector Claude can read that library, or with full scopes write to projects and content as the signed-in user.",
  ]}
/>

To create a Claude skill, make a folder that holds a SKILL.md file: a short header that names the skill and says when Claude should use it, then the instructions, with long material such as a scorecard in separate reference files. Upload the folder to Claude as a zip file, or save it in Claude Code's skills folder, and test it before anyone else relies on it.

A skill holds a method Claude loads when a task calls for it; see [how a skill differs from a project or a saved prompt](/blog/claude-skills-vs-projects-for-rfps).

This guide builds our AI Go/No-Go Agent Skill (version 1.1) file by file. The go/no-go is the first step in [how bid teams use Claude across a whole RFP](/blog/claude-for-rfp), and the steps work for any skill.

## Before You Create a Claude Skill, Plan What It Decides

Write down four things before the first file:

- **The job:** a recommendation on one tender.
- **The inputs:** the tender files and your company profile.
- **The output:** a scored report with the evidence behind every score.
- **What it never decides:** the bid itself. Our SKILL.md says the skill "does not make the final bid decision".

Where the go/no-go sits in [the bid management process](/blog/bid-management), and [what a go/no-go review should weigh](/blog/rfp-go-no-go), have their own guides; the skill packages your method so Claude works through the same steps on every tender.

## What Goes in a SKILL.md File?

A SKILL.md file is a Markdown file with a short header that names the skill and says when to use it, followed by the instructions Claude follows once the skill loads.

The go/no-go skill needs one folder with two files:

```text
ai-go-no-go/
├── SKILL.md
└── references/
    └── go-no-go-framework.md
```

The header is YAML. This is our package's real one:

```yaml
---
name: ai-go-no-go
description: Performs AI-powered Go/No-Go analysis on tender and RFP documents against your company profile and a structured decision framework. Use this skill whenever a user uploads tender documents, RFP packages, or ITT files and wants to determine whether to bid. Also trigger when users say "should we bid on this", "analyze this tender", "go no-go", "bid decision", "evaluate this RFP opportunity", or upload multiple procurement documents for assessment. Works with any company by analyzing their website and matching against tender requirements.
---
```

Anthropic's rules (November 2026):

- **`name`:** up to 64 lowercase letters, numbers, and hyphens, without "anthropic" or "claude" ([Agent Skills overview](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)).
- **Header keys:** for claude.ai and API uploads, only `name`, `description`, `license`, `compatibility`, `metadata`, and `allowed-tools` ([Claude Code docs](https://code.claude.com/docs/en/skills)).
- **Folder name:** the same as `name` ([How to create custom Skills](https://support.claude.com/en/articles/12512198-how-to-create-custom-skills)). Ours differs, so fix it in your copy.
- **Body:** under 500 lines, with reference files one level deep ([authoring best practices](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices)).

Claude reads SKILL.md only when a request matches the description, and opens a reference file only when SKILL.md points to it.

### Write the Description So Claude Knows When to Use It

The description decides when the skill loads:

- **Say what it does and when to use it,** in the third person, with the phrases people type.
- **Make it "pushy".** Anthropic's [skill-creator](https://github.com/anthropics/claude-plugins-official) advises this because Claude tends to under-trigger skills (November 2026).
- **Describe the input you expect.** Ours promises to analyze a website, while our tests supplied company files.
- **Test the length.** Anthropic's platform docs allow 1,024 characters and its Help Center 200 (November 2026). An earlier version of this skill, with a 570-character description, has loaded from our claude.ai account since May 2026, but test-upload yours before the team relies on it.

### Where Claude Skills Are Stored

| Surface               | Where the skill goes                                                                               | Who gets it                       |
| --------------------- | -------------------------------------------------------------------------------------------------- | --------------------------------- |
| claude.ai             | Upload a zip with the skill folder at its root, then switch it on under **Customize** > **Skills** | You                               |
| Claude Code, personal | `~/.claude/skills/<name>/SKILL.md`                                                                 | You, in every folder              |
| Claude Code, project  | `.claude/skills/` inside the folder you work in                                                    | Everyone who works in that folder |

For the hands-on steps, see [installing a skill and running it on a tender folder in Claude Code](/blog/getting-started-with-claude-code-for-rfps).

## Turn Your Go/No-Go Scorecard Into a Reference File

Keep the scorecard in its own reference file, so the bid team can edit categories, weights, and thresholds without touching the instructions. Ours holds seven weighted categories and 30 questions, each scored 1 to 5 with guidance for a 5, a 3, and a 1.

| Category                     | Weight | Example question from the file                                              |
| ---------------------------- | ------ | --------------------------------------------------------------------------- |
| Strategic Alignment          | 20%    | "Does the issuing organization match our Ideal Customer Profile?"           |
| RFP Origins & Relationship   | 10%    | "Do we have executive sponsorship or a champion inside the organization?"   |
| Competitive Landscape        | 10%    | "Are we the incumbent, or are we trying to unseat an existing vendor?"      |
| Resource Requirements        | 15%    | "Are the required SMEs available to contribute within the response window?" |
| Commercial Viability         | 15%    | "Is there a clear, realistic budget stated or implied?"                     |
| Requirement Fit              | 20%    | "Does the required deployment model match what we offer?"                   |
| Legal, Security & Compliance | 10%    | "Do we hold the mandatory certifications required?"                         |

The same file holds three more rules:

- **Thresholds:** 80% and above Strong Go, 65 to 79% Conditional Go, 50 to 64% Executive Review, below 50% No-Go. Keep them only here, and write bands without gaps ("65% to under 80%").
- **Missing input:** questions only the team can answer, such as bandwidth, are flagged REQUIRES USER INPUT, left out of the average, and reported as a range.
- **Your own weights:** weight compliance higher in regulated work, and mark hard constraints such as SaaS-only as potential deal-breakers.

### Write the Arithmetic Into the Reference File

Write down how 1 to 5 scores become a percentage, or Claude will choose a formula, and the choice can change the answer. A tender averaging 3.5 everywhere scores 70% (Conditional Go) under category average ÷ 5 × weight, and 62.5% (Executive Review) under (average minus 1) ÷ 4.

Our framework file now has a "How to Calculate the Score" section. Steps 3 to 5, quoted, then the last two by heading:

```text
3. Category points. Category points = category average ÷ 5 × category weight. For
   example, a category averaging 4.0 with a 20% weight earns 16.0 points.
4. Overall percentage. Overall percentage = total category points ÷ total weight of the
   scored categories × 100. When every category is scored the weights add up to 100,
   so the percentage is simply the total points.
5. Range for missing input. Recalculate with every REQUIRES USER INPUT question set to 1,
   then to 5, and report the result as a range beside the provisional percentage. If the
   range crosses a decision threshold, say which inputs would move it.
6. Deal-breakers override the percentage.
7. Thresholds last.
```

Then tell SKILL.md to follow it "exactly" and show the arithmetic. State the rounding too: a score near a threshold can cross it on rounding alone.

### Say What Happens When a Deal-Breaker Appears

Write down what a deal-breaker does to the decision, or Claude will decide. Our rule: a mandatory requirement the company cannot meet makes the decision No-Go whatever the percentage, unless the user confirms the gap can be closed before submission, which caps it at Executive Review.

<ConceptFigure
  kind="branch"
  title="A deal-breaker overrides the weighted score"
  highlight={1}
  steps={['Score, then check for deal-breakers']}
  outcomes={[
    { label: 'Deal-breaker the team cannot close', end: 'No-Go, whatever the score' },
    { label: 'Team confirms the gap can be closed', end: 'At most Executive Review' },
    { label: 'No deal-breaker', end: 'The score sets the decision band' },
  ]}
/>

Define the term, too, so a budget below your floor and a missing mandatory certification are scored differently.

<BlogCta id="go no go decision template cta" />

## Give the Skill a Company Profile to Score Against

A go/no-go skill can only score fit against what it knows about your company, so give it a profile: what you sell, what you will not do, your commercial floor, and your bid capacity.

Our SKILL.md tells Claude to "ask for one before proceeding" when none arrives. A profile needs these sections:

```text
Company profile: [company name], dated [month year]

Products and deployment model:
Hosting and data residency:
Certifications held:
Customers and sectors:
What we do not offer:
  - deployment models, certifications, or security terms you will not accept
Commercial floor: minimum annual contract value; maximum discount without sign-off
Bid team capacity this month:
```

The profile often decides the bid:

- **State the "do not offer" list and the floor plainly.** They turn a fair score into No-Go.
- **Be precise about data access.** One line giving staff abroad standing access to customer data can turn data residency into a deal-breaker.
- **Keep one current, dated profile,** and move superseded policies out of the folder.

| Keep the profile                        | Each change needs   | Suits                              |
| --------------------------------------- | ------------------- | ---------------------------------- |
| Inside the skill, as a reference file   | A new skill version | Teams whose profile rarely changes |
| Beside each tender, as a bid brief file | A file edit         | Teams whose profile changes often  |

## Draft It With Anthropic's Skill-Creator, Then Edit by Hand

Anthropic's skill-creator drafts a skill from a conversation; the useful work is editing that draft until it matches how your bid team decides.

- **On claude.ai,** ask Claude to create a skill and answer its questions; Claude packages it for you to switch on ([Claude Academy tutorial](https://academy.claude.com/tutorials/how-to-create-a-skill-with-claude-through-conversation), November 2026).
- **In Claude Code,** run `/plugin install skill-creator@claude-plugins-official`. Anthropic's Claude Code docs say it can run test prompts with and without the skill, grade them, and tune the description (November 2026).

Then edit by hand: swap generic categories and weights for your own, write in the formula and the deal-breaker rule, and keep SKILL.md short, with detail in reference files.

## How Do You Test a Claude Skill?

Test a skill before you share it: check that it loads for the right requests, check its output on real work, and compare it with Claude's answer when the skill is off, as Anthropic's [guide to building skills](https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf) advises (November 2026).

| Test                 | What it checks                       | How to run it                                                                                                |
| -------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
| Trigger              | It loads for the right requests only | Run each prompt below in a fresh chat, three times, and record whether the skill loaded                      |
| Function             | The output is right on real work     | Run it on a tender you have already decided, and check every finding against the files                       |
| Baseline             | The skill adds something             | Ask the same question with the skill off, and compare                                                        |
| Planted deal-breaker | The override fires                   | Change one profile line so the company fails a mandatory requirement, and check for No-Go whatever the score |

Trigger prompts to start with:

| Prompt                                                   | Should the skill load? |
| -------------------------------------------------------- | ---------------------- |
| "Should we bid on this?"                                 | Yes                    |
| "Is this opportunity worth pursuing? Qualify it for us." | Yes                    |
| "Summarise the attached RFP in five bullet points."      | No                     |
| "What does a go/no-go decision mean in bid management?"  | No                     |

We haven't published trigger results for this skill yet.

### What to Check in the Output

Check four things in every output:

- **Sources:** every requirement or Q&A number it cites exists in the tender.
- **Arithmetic:** recompute each category, the total, and every "what if" line from the stated formula.
- **Counts:** compare any count of requirements with the tender itself.
- **Open items:** anything the files cannot answer is listed as open, with no score.

## On a Public Tender, the Skill Added a Checkable Score to the Same No-Go

Our test tender was State of Maine RFP# 202506081 ([RFP archive](https://www.maine.gov/dafs/bbm/procurementservices/vendors/rfps/rfp-archives)), issued July 15, 2025, in which a state agency sought case management software. The bidder was fictional and does not offer CJIS, a security standard the tender's Q&A made mandatory. Each test ran once in a Claude Code session (Claude Opus 5.5; version 1.0 on November 6, 2026, version 1.1 on November 9), and a claude.ai chat may differ. The same team wrote the skill and the answer keys.

| Test (one run each)  | November 9 run, skill version 1.1                                                                                 | November 6 run, skill version 1.0                                                                                                                                                                                             |
| -------------------- | ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Function test        | No-Go, 49.2%; every figure reproduces under the stated formula; the deal-breaker override applied (CJIS, Q&A 175) | No-Go, 47.7%; 9 questions left for user input; one sensitivity figure wrong                                                                                                                                                   |
| Planted deal-breaker | No-Go, 48.2%; both deal-breakers named (staff access from Canada; CJIS) and the override applied                  | No-Go, 43.1%                                                                                                                                                                                                                  |
| Baseline, no skill   | Not re-run                                                                                                        | No-Go, no score, naming the five issues the skill run found: CJIS, a $54,000 budget below the bidder's $60,000 minimum, an October 1, 2025 go-live against a 24-week implementation, the incumbent, and custom lab interfaces |

Claude reached No-Go with and without the skill. The skill added a weighted score with the arithmetic shown, a decision band, and a stated override, so each tender is scored against the same questions and the result can be checked. The planted deal-breaker scored only 1.0 point below the base case, so the override did the work the percentage could not.

## Version the Skill and Share It With Your Bid Team

Share one versioned package that everyone installs from the same place, and send every change back through the same tests before the team gets it. Each release carries a version line under `metadata` in the header and a short changelog.

<ConceptFigure
  kind="cycle"
  title="Every change goes back through the tests before the team gets it"
  highlight={3}
  items={[
    'Test on the same tenders and prompts',
    'Change the files to fix what the tests found',
    'Rerun the same tests with the same inputs',
    'Release to the one place everyone installs from',
  ]}
  loop="Next change"
/>

Our version 1.0 to 1.1 change (November 9, 2026) is a typical fix. Step 5 of SKILL.md gave no formula and no deal-breaker rule; version 1.1 points to the framework's scoring section and writes the override in:

```diff
-2. Calculate the overall weighted percentage
-4. Identify any hard deal-breakers (requirements the company fundamentally cannot meet)
+Follow "How to Calculate the Score" in `references/go-no-go-framework.md` exactly, and
+show the arithmetic in the scorecard so anyone can check it:
+4. Check for hard deal-breakers (mandatory requirements the company fundamentally cannot
+   meet). A deal-breaker makes the decision No-Go whatever the percentage, unless the user
+   confirms it can be resolved before submission; then the decision is at most Executive
+   Review.
```

Version 1.1 still leaves fixes for your copy: the folder name, the "website" line, the threshold wording, a header version line, and the nested `rfp-shredder/`, which needs its own folder to load in Claude Code.

| Plan or surface     | How to share                                                                                                                                                                           |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Team and Enterprise | An Owner adds it under **Organization settings** > **Plugins & skills**; it is on for everyone, and a Publishing setting (Requires review, Open, or Off) controls what members publish |
| Other plans         | Send the `.skill` file for each person to upload, or share it from claude.ai as a view-only copy                                                                                       |
| Claude Code         | Keep the package in the team folder's `.claude/skills/`                                                                                                                                |

On Team and Enterprise, approved updates reach users automatically, and Anthropic changed the Enterprise default in November 2026, so check your setting ([Provision and manage skills for your organization](https://support.claude.com/en/articles/13119606-provision-and-manage-skills-for-your-organization)).

Install skills only from sources you trust, and read their files first, as Anthropic advises; see [what to check before you install a skill someone else wrote](/blog/is-claude-safe-for-rfps).

<BlogCta id="Claude skills library" />

## Where AutoRFP.ai Fits Under a Go/No-Go Skill

A go/no-go skill is only as current as the company facts it reads, and AutoRFP.ai keeps those facts current by drafting every answer from content the bid team has approved and showing the source behind it. Questions such as 4.3 (how much of the response can reuse existing content) depend on that library.

AutoRFP.ai is [AI proposal software that answers from your approved library](/ai-proposal-software): it writes each draft from approved content, shows the source, and hands any question it cannot support to a person. Claude reaches that library through AutoRFP.ai's MCP connector, which lets it look content up with read scopes and, with full scopes, write to projects and content. Every action runs as the signed-in user, and approvals happen in AutoRFP.ai's workflow.

[AutoRFP.ai's go/no-go screening](/features/go-no-go) runs the same kind of check inside the platform: your team sets the screening questions once, each RFP is answered against them with every result tied to its source file, and a requirement the team cannot meet is flagged as a deal-breaker before anyone starts drafting.

<SnapshotGrid
  items={[
    {
      slug: 'deal-breaker-scan',
      title: 'A requirement the team cannot meet is flagged before drafting',
      body: "An uploaded RFP screened against the team's own go/no-go criteria, with an on-premise requirement flagged as the deal-breaker.",
    },
  ]}
/>

If you are weighing a Claude skill against a platform for the whole team, see [when a Claude skill is enough and when a bid team needs RFP software](/blog/chatgpt-or-claude-vs-rfp-software).

## Check These Before the Bid Team Relies on Your Skill

Run these checks before anyone uses the skill on a live bid, then download the finished package and adapt it.

<ConceptFigure
  kind="checklist"
  title="A skill is ready for a live bid when it passes these checks"
  checks={[
    { lead: 'Description.', text: 'Says what the skill does and when to use it.' },
    { lead: 'Name.', text: 'Matches the folder and uses only lowercase letters, numbers and hyphens.' },
    { lead: 'Scorecard.', text: 'Weights, thresholds and the scoring formula live in one file.' },
    { lead: 'Deal-breakers.', text: 'SKILL.md says a hard deal-breaker means No-Go whatever the score.' },
    { lead: 'Open items.', text: 'Anything the files cannot answer is flagged REQUIRES USER INPUT, with no score.' },
    { lead: 'Triggers.', text: 'It loads for "should we bid on this" and stays out of unrelated requests.' },
    {
      lead: 'Tests.',
      text: 'Run on a tender you have already decided, with and without the skill, and once with a planted deal-breaker.',
    },
    { lead: 'Version.', text: 'The header carries a version line, and the change is noted.' },
  ]}
/>

Download [the full AI Go/No-Go skill package](/skills/ai-go-no-go-agent-skill) (version 1.1) from AutoRFP.ai's skills library. It is free and unlocked with an email address, and comes as a `.skill` file for Claude with versions for other assistants. Once the decision is Go, the package's "Works Well With" list points to the next skill: the Compliance Matrix Builder.

<BlogCta id="Dark blue demo cta" />