Skip to content

Makes

Self-reported attribution

Adds a free-text "How did you hear about us?" field, codes the answers into channels and sets them beside software attribution, with the gaps named.

Other tools

Add this skill to Claude

Claude takes skills as a ZIP file. Your download has started; if it didn't, use the button below.

  1. 1In Claude, open Customize, then Skills.
  2. 2Choose +, then Upload a skill, and pick self-reported-attribution.zip.
  3. 3Ask for it by name, or let Claude use it when a task matches.

Skills need code execution turned on in Claude's settings. On a Team or Enterprise plan, an admin can share it with everyone.

Download the folder

Try it now, without installing

See the skill work on a made-up input before you add it. Nothing is installed, and you can swap in your own input.

Open in the Claude app

Opens a new chat in the Claude desktop app with the prompt filled in. Nothing is sent until you press enter.

Includes the whole SKILL.md and the sample input. Paste it into Claude, ChatGPT or any chat.

Influenced by
Hybrid Attribution Framework
Needs
The forms where leads come in
Works with
Claude, ChatGPT, Codex, Cursor and any agent that reads SKILL.md
Version
1.0.0 · Last checked · License MIT
Maintained by
Sabih AhmedMarkOps
SkillMarkOps

Self-reported attribution

Example output

What buyers said, and what software saw
Buyers saidSoftware saidRead
PodcastDirect trafficDemand made
GoogleOrganic searchUnclear
LinkedIn adPaid socialBoth agree

Adds a free-text "How did you hear about us?" field, codes the answers into channels and sets them beside software attribution, with the gaps named.

The skill

The whole skill, in plain text.

Nothing is hidden. Read it, change it to fit your team, or take the whole folder.

Scripts
Optional Python scripts for the counting. It works without them and says which way it ran.
Network
Doesn't need the internet.

3 test cases

self-reported-attribution/SKILL.md

In the folder

  • self-reported-attribution/SKILL.md
  • self-reported-attribution/references/code-book.csv
  • self-reported-attribution/scripts/code_answers.py
---name: self-reported-attributiondescription: >-  Adds a free-text "How did you hear about us?" field to a B2B SaaS company's high-intent forms, codes the answers  into channels with an editable code book, counts them by answer, opportunity and pipeline, and sets them beside  software attribution with the gaps named, including memory bias and answers that describe navigation, not  discovery. Use it when software attribution credits direct and branded search for most pipeline, when podcasts,  communities, events or founder posts can't be measured, or to set up the field before a quarter starts. Not for  UTM naming (use utm-check) or the channel report itself (use pipeline-report, which reads this).license: MITcompatibility: >-  Works in Claude, ChatGPT, Codex, Cursor and any agent that reads SKILL.md. Reads a connected CRM read-only if the  agent has one, otherwise a CSV export or pasted answers. Python 3 is optional, for coding and counting.metadata:  author: SHAKEUP  version: "1.0.0"  stage: make  plugin: markops  homepage: https://www.shakeuphq.com/skills/self-reported-attribution--- # Self-reported attribution Asks buyers where they heard about the company, turns their words into channels, and shows what software attribution can't see. ## Purpose - One job: make the self-reported view (the field, the code book, the coded counts) and set it beside software attribution, then check it before handing it over.- Stage: make. It ends with its own check, at most 2 rounds.- It never adds the 2 views together or blends them into one share. They answer different questions: what made the buyer aware, and what brought the visit.- It never changes a form or a CRM. It writes the spec; people build it. ## Use when / not | Situation | Use || --- | --- || Software attribution credits direct traffic and branded search for most pipeline | this skill || Podcasts, communities, events, peers or founder posts can't be measured | this skill || Setting up the field before a quarter | this skill, mode `field` || Answers exist and need coding | this skill, mode `code` || UTMs land in the wrong channel | `utm-check` || Pipeline per channel for the board | `pipeline-report`, which reads this skill's handoff | ## Inputs | Input | Required | Ways to provide, in order | If missing || --- | --- | --- | --- || The answers (mode `code`), with record date, software source (original source), opportunity yes or no, amount, won | yes in mode `code` | a connected CRM, read-only; a CSV export; pasted rows | switch to mode `field` || The forms and where leads enter (demo, contact sales, trial, content downloads) | yes in mode `field` | the reader; browse the site | ask once || Names worth coding: shows the company sponsors, communities, events, newsletters, partners, people who post | no | `## Channels`; the reader | code with the generic code book; open item || Software attribution per record | no | the same CRM export (original source); a GA4 export | the comparison is `not available`; coverage `partial` || The `utm-check` handoff | no | its handoff block | name software channels as the CRM writes them | ## Profile read From `company-profile.md`: `## Company` (Brand terms, so the brand's own name isn't coded as a channel; Business model, for where to ask), `## Channels` (names of shows, communities and partners to add to the code book), `## Buyers` (who fills the forms), `## Accounts and data` (CRM), and every `## Learnings` entry for `self-reported-attribution` (accepted phrases join the code book). No profile: ask for the CRM, the forms where leads enter, and the names of any podcasts, communities, events or partners the company is part of, in one message. Say that `company-profile` saves this next time. ## Steps 1. **Apply learnings.** Add every accepted phrase to the code book before coding. Name each one used. 2. **Pick the mode.**    | Condition | Mode |   | --- | --- |   | No answers collected yet, or under 10 | `field` (steps 3 and 8 to 10) |   | Answers exist | `code` (steps 4 to 10); add step 3 if the field breaks a rule below | 3. **Write the field spec.**    | Rule | Why |   | --- | --- |   | Free text, no dropdown | A list anchors answers to the options shown and hides channels nobody listed |   | Label: "How did you hear about us?" | Plain words; the buyer answers about awareness, not about the last click |   | Required on demo, contact sales and trial forms; leave it off content downloads | The answer matters where pipeline starts; on every download the same person answers many times |   | Placed after the contact fields, before submit | Asked once the buyer has decided to send |   | No prefill, no minimum length | A prefilled or forced answer is the form's words, not the buyer's |   | Stored in a first-answer property that is never overwritten, plus a latest-answer property | The first answer belongs to the lead's creation; later forms shouldn't erase it |   | Copied to the opportunity when it is created | Pipeline is reported per opportunity |   | In a sales-led motion, sales asks the same question on the first call when the form had none, in its own field | Leads from outbound and events skip the form |    Keep UTMs and click IDs in hidden fields beside it: that is the software view this skill compares against. 4. **Prepare the code book.** Start from `references/code-book.csv`. Add the reader's own names (shows, communities, newsletters, events, partners, people who post) to the right code. Never add the company's own brand terms. 5. **Code and count.** Run the script:    ```   python3 scripts/code_answers.py --csv answers.csv --extra "podcast=<show name>" --extra "linkedin_post=<founder name>"   ```    Without Python, by hand: lowercase each answer; mark blank and unsure ("don't know", "not sure") answers apart; an answer no code matches is junk when it is n/a, test, a keyboard run or has no letters, else uncoded (a short answer a code matches, such as "G2", is coded); match the code book's phrases as whole words, and when a short phrase sits inside a longer match ("linkedin" inside "linkedin ad"), keep the longer one; an answer can carry several codes, and the first one mentioned is its primary code. Count primary codes and all mentions. Say which way you ran it. 6. **Set the views side by side.** For each code: primary answers, share of coded answers, opportunities, pipeline and won, next to what software attribution said for the same records (the top 3 software sources). Then the reading table:    | Self-reported | Software | Read it as |   | --- | --- | --- |   | High | Low or absent | Demand made where software can't see (podcasts, peers, communities, AI assistants). Track it by its self-reported trend |   | Low | High | The channel catches demand made elsewhere (direct, branded search, retargeting). Judge it on cost per opportunity, not on credit for creating demand |   | High | High | Both views agree |   | Low | Low | A candidate to cut, after 2 quarters of answers |    "High" and "low" are relative to the other channels in the same run, never to an outside figure. 7. **Name the gaps.** Every output lists these, with the counts that show their size:    | Gap | What it does | How the output handles it |   | --- | --- | --- |   | Memory bias | Buyers name the touch they remember, often the latest or most vivid one, not the first | Report self-reported as awareness, never as first touch |   | Navigation answers | "Google" often means how they reached the site after hearing elsewhere | Code `search` is unclear: never credit organic or paid search from it alone |   | Platform with no type | "LinkedIn" alone doesn't say ad or post | Code `linkedin` is unclear: credit neither |   | Who answers | Only people who filled a form with the field answer | Report the answered share and the junk and unsure shares |   | Small counts | One answer moves a small share a lot | Shares only from 30 coded answers; codes under 5 marked too few |   | Software blind spots | Software can't see conversations, audio or private shares | Shown by the cross-table, not corrected | 8. **Check the result** (the loop below). 9. **Say how long until enough answers.** In mode `field`, or under 30 coded answers: from the reader's monthly demo and contact form volume, the months until 30 coded answers. Without a volume, write `not available`. 10. **Hand over** with the handoff block. ## Check and verdict Checks: | ID | Passes when || --- | --- || S1 | Mode `field`: the spec follows every rule in step 3. Mode `code`: the existing field breaks none of the step 3 rules that the answers or the reader show (many identical answers point to a dropdown) || S2 | Uncoded answers are 10% or less of text answers, after at most 2 rounds of adding phrases || S3 | Shares appear only with 30 or more coded answers; codes under 5 are marked too few || S4 | No code credits search or a platform's ads from an unclear answer || S5 | The 2 views are side by side and never added together || S6 | Every gap in step 7 is named with its count || S7 | Brand terms are not coded as a channel | | Verdict | Condition (first match wins) || --- | --- || `BLOCKED` | No answers and no way to know where leads enter || `FIELD READY` | Mode `field`: the spec passes S1 || `NOT ENOUGH ANSWERS` | Under 30 coded answers: counts only, no shares, and the months until 30 || `READY WITH GAPS` | Checks pass, and software attribution or the opportunity link is missing, or S2 still fails after 2 rounds || `READY` | Every check passes with both views present | Named stops: `BLOCKED` asks where leads enter. `NOT ENOUGH ANSWERS` stops before any share or channel ranking. No other stops. ## Loop 1. Run S1 to S7.2. Fix: for S2, read each uncoded answer; when it names a channel, add the phrase to the code book (or the reader's `--extra`), then code again. For S3, hide the shares. For S4, move the credit to the unclear code. For S7, remove the brand phrase.3. Check again. At most 2 rounds; list the answers still uncoded. ## Learn - A phrase added to the code book during the loop: write a `fact` learning (`"<phrase>" codes as <code>`), so the next run starts with it.- The reader recodes an answer: write a `proposal` with the phrase and the new code.- After each quarter, the counts per code: write a `fact` so the trend is visible next quarter. Example: `- 2026-10-24 | self-reported-attribution | fact | "the ops room" codes as community | Why: 6 answers in Q3 named it (CRM export, 2026-10) | Status: noted` ## Output ```Verdict: <READY | READY WITH GAPS | NOT ENOUGH ANSWERS | FIELD READY | BLOCKED> · Coverage: <complete | partial (what's missing)> · Coding: <script | by hand> · Rounds: <n>Answers: <rows> rows · <n> answered (<n%>) · <n> coded · <n> uncoded · <n> junk · <n> unsure | Code | Group | Primary | Share of coded | Mentions | Opportunities | Pipeline | Won | Software said |(by primary answers; shares only from 30 coded answers; "too few" under 5) Reading: <one line per code from the reading table>Gaps: <each gap with its count>Still uncoded: <answers>Field spec: <table, mode field or when the field breaks a rule>Months until 30 coded answers: <n or not available>Learnings applied: <list, or none>``` Then the handoff block. ## Hand off ```handoffskill: self-reported-attributionversion: 1.0.0verdict: READY WITH GAPScoverage: partial (no software source on 12 records)for: <company> demo and contact forms, <period>outputs:  coded_answers: 84  top_codes: {podcast: 23, word_of_mouth: 17, search: 11}  dark_share_of_coded: 0.55  pipeline_by_code: {podcast: 412000, word_of_mouth: 260000}  code_book_additions: ["the ops room: community"]next: [pipeline-report]open: [12 records without software source]``` `pipeline-report` reads `pipeline_by_code` to show the self-reported column beside software channels. ## Failure modes | Problem | Do this || --- | --- || The field is a dropdown | Code the options as given, flag S1, and write the free-text spec || Answers in several languages | Code only the languages the code book covers; list the rest as uncoded with the language named || The reader wants one blended attribution share | Decline the blend: the views answer different questions. Show them side by side || A competitor's name appears in answers | Add the names as `--extra "competitor_mention=<name>"`; report that code apart, since it isn't a channel || The reader asks what share of answers is normal | There's no outside figure here; compare with their own last quarter || Answers include personal names | Code the role ("my boss" is word of mouth); don't repeat private individuals' names in the output | ## Influenced by - Refine Labs' Hybrid Attribution Framework, which pairs what buyers say with what software records, especially for channels software misses: https://www.refinelabs.com/article/hybrid-attribution-framework- SHAKEUP's MarkOps practice: a free-text field, an editable code book with unclear codes for navigation answers, and no blended share.

How it thinks

Inputs in, a verdict out, and a stop only where you decide.

What we built

We code free text with an editable code book, keep navigation answers like "Google" unclear instead of crediting search, and never blend the 2 views into one share. They answer different questions, so they sit side by side.

It reads your company profile if you have one, or asks for only what it needs. Then it works through its steps, checks its own work and ends in a verdict.

The steps

  1. 01

    Read your learnings first

    Phrases your team added to the code book in earlier runs join it before any answer is coded.

  2. 02

    Write the field, or check the one you have

    Free text, never a dropdown, required on demo and trial forms, kept in a first-answer property that is never overwritten and copied to the deal.

  3. 03

    Code the answers

    Its script matches an editable code book as whole words. The longer phrase wins, so "LinkedIn ad" isn't read as "LinkedIn", and the first channel named is the primary one.

  4. 04

    Set the 2 views side by side

    What buyers said next to what software recorded, per channel, with opportunities and pipeline. They are never added into one share.

  5. 05

    Name the gaps

    Memory bias, "Google" as how they reached the site rather than how they heard, platform names with no type, who answers, and small counts.

  6. 06

    Check it, at most 2 rounds

    Uncoded answers go back into the code book until 1 in 10 or fewer is left, and no share appears under 30 coded answers.

What you need

  • Optional

    The answers, with each record's software source, opportunity and amount

    A connected CRM, read-only → A CSV export → Answers you paste

  • Required

    The forms where leads come in

    Your request → It reads your site if your agent can browse

  • Optional

    Names worth coding (shows you sponsor, communities, events, partners, people who post)

    The Channels section of your company profile → Your request

What it can return

  • READY

    Answers coded and set beside software attribution, with every check passed.

  • READY WITH GAPS

    The checks pass, but software sources or the opportunity link are missing for some records.

  • NOT ENOUGH ANSWERS

    Fewer than 30 coded answers. It gives counts only, and the months until there are enough.

  • FIELD READY

    You don't collect answers yet. It writes the field and where to store it.

  • BLOCKED

    No answers and no way to know where leads come in.

Where it stops for you

  • When there are no answers and no forms to add the field to
  • When there are fewer than 30 coded answers, before any share or ranking

Example output

What you get back.

A run for a made-up company. Your output depends on your inputs.

Here's a run for a made-up B2B SaaS company that sponsors a podcast and is active in a Slack community. Software attribution credited most of its pipeline to direct traffic and organic search.

Verdict

READY

Coverage: complete

Coding: script

Rounds: 2

CodePrimary answersShare of codedOpportunitiesPipelineSoftware said
Podcast1434%6$144,000Direct traffic 9, organic search 5
Word of mouth717%3$74,000Direct traffic 4, organic search 3
Search (unclear)615%1$20,000Organic search 6
LinkedIn (unclear)4, too few10%1$24,000Paid social 4
Community3, too few7%1$22,000Direct traffic 3
Read

the podcast made demand that software filed under direct traffic and organic search. The "Google" answers stay unclear, since most describe how buyers reached the site.

Gaps

memory bias, 6 navigation answers, 4 LinkedIn answers with no type, and 3 answers that were junk or unsure.

The handoff block the next skill reads
skill: self-reported-attribution
version: 1.0.0
verdict: READY
coverage: complete
for: demo form, July to September 2026
outputs:
  coded_answers: 41
  top_codes: {podcast: 14, word_of_mouth: 7, search: 6}
  pipeline_by_code: {podcast: 144000, word_of_mouth: 74000}
next: [pipeline-report]
open: []

What good looks like

  • A free-text field, required where pipeline starts
  • Answers like "Google" kept unclear, not credited to search
  • Counts first, and shares only from 30 coded answers
  • Both views side by side, never blended
  • Every gap named with its count

Install

Use it in the tool you already have.

Pick your tool. Each tab has the shortest path we know of.

  1. 01
  2. 02
    In Claude, open Customize, then Skills.
  3. 03
    Choose +, then Upload a skill, and pick the ZIP. Code execution must be on in your settings.
  4. 04
    Ask for it by name, or let Claude use it when a task matches.

Questions

Before you add it.

Why free text and not a dropdown?

A list anchors answers to the options you thought of and hides the rest. Free text keeps the buyer's own words, and the code book turns them into channels.

What happens to answers that just say "Google"?

They stay an unclear search code. Most describe how the buyer reached your site after hearing about you somewhere else, so they don't count as credit for organic or paid search.

How many answers does it need?

30 coded answers before it shows any share. Below that, one answer moves a share by more than 3 points, so it gives counts and the months until there are enough.

Can I change the code book?

Yes. It's a plain file of codes and phrases. Add the names of the shows, communities and partners your buyers mention, and every run after uses them.