Skip to content

Makes

CRM feedback loop

Plans which CRM stages to send back to Google, LinkedIn, Meta and ChatGPT Ads so they bid for pipeline, even when your sales cycle outlasts their windows.

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 crm-feedback-loop.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
Enhanced conversions for leads, Conversions API documentation, Conversions API for CRM integration, Conversions API
Needs
Leads with the date they reached each stage, platform or source, and won amount · Your stage names and what moves a record into each
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

CRM feedback loop

Example output

What each platform bids on
PlatformBid onWhy
Google AdsSQL82% inside 63 days
LinkedIn AdsOpportunityAll inside 365 days
Google AdsClosed-won75% outside window

Plans which CRM stages to send back to Google, LinkedIn, Meta and ChatGPT Ads so they bid for pipeline, even when your sales cycle outlasts their windows.

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
Opens web pages or your tools if your agent can. Works from pasted data if not.

3 test cases

crm-feedback-loop/SKILL.md

In the folder

  • crm-feedback-loop/SKILL.md
  • crm-feedback-loop/references/platform-windows.md
  • crm-feedback-loop/scripts/stage_timing.py
---name: crm-feedback-loopdescription: >-  Plans and checks how a B2B SaaS company sends CRM stages (MQL, SQL, opportunity, closed-won) back to Google Ads,  LinkedIn Ads, Meta Ads and ChatGPT Ads so they bid for pipeline instead of form fills. Measures each stage's timing  against each platform's documented window, picks the stage each platform should bid on, values stages from the  company's own stage-to-won rates, and handles sales cycles longer than the windows. Use it when platforms bid on  leads that never become pipeline, before setting up offline imports or a conversions API, or when the sales cycle  changes. Not for checking existing tracking (use tracking-audit first) or reporting pipeline (use pipeline-report).  It recommends; it never changes an account.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 rows. Opens the platforms' documentation if the agent can browse.  Python 3 is optional, for the stage timing.metadata:  author: SHAKEUP  version: "1.0.0"  stage: make  plugin: markops  homepage: https://www.shakeuphq.com/skills/crm-feedback-loop--- # CRM feedback loop Turns CRM stages into the signal each ad platform bids on, within the time each platform allows. ## Purpose - One job: produce a feedback plan per platform (which stage it bids on, which it reports, with what value, sent how and how often) and check the plan before handing it over.- Stage: make. It ends with its own check, at most 2 rounds.- It never changes an ad account, a CRM or an integration. It writes the spec; people build it.- It never invents a window, a limit, a conversion rate or a stage value. Windows come from `references/platform-windows.md` (dated, cited); rates and values come from the reader's CRM. ## Use when / not | Situation | Use || --- | --- || Platforms bid on leads that sales rejects | this skill || Setting up offline imports or a conversions API | this skill, after `tracking-audit` || The sales cycle got longer, or a new platform starts | this skill || Imports exist but the data looks wrong | `tracking-audit` || Building the score that could serve as an early stage | `lead-scoring` || Reporting pipeline per channel | `pipeline-report` | ## Inputs | Input | Required | Ways to provide, in order | If missing || --- | --- | --- | --- || Leads with their stage dates (created or click date, MQL, SQL, opportunity, closed-won), platform or source, and won amount, last 12 months | yes | a connected CRM, read-only; a CSV export of contacts or leads with stage date properties; pasted rows | `BLOCKED`: ask for the export || Stage definitions: names and entry rules | yes | CRM settings; the reader | ask once; without them, use the export's column names and mark them unconfirmed || The `tracking-audit` handoff: match key rate per platform, existing imports, stage dates | no | the handoff block; else check click ID columns in the export | measure the click ID share from the export; coverage `partial` || Platforms in scope | no | `## Channels`; the reader | every paid platform marked `active` || Each platform's current window settings (conversion action windows, LinkedIn rule types, Meta attribution setting) | no | a connected ad account, read-only; screenshots; the reader | plan with the documented limits; open item || A `lead-scoring` handoff with verdict READY | no | its handoff block | no predicted stage option | ## Profile read From `company-profile.md`: `## Company` (Sales cycle, Average deal size, Regions for consent, Business model), `## Channels` (paid platforms, status, budget), `## Targets` (opportunity to closed-won rate, as a cross-check only: the plan uses rates measured from the export), `## Accounts and data` (CRM, connected ad accounts), and every `## Learnings` entry for `crm-feedback-loop`. No profile: ask in one message for the paid platforms, the CRM, the stage names and the regions the company sells in. Say that `company-profile` saves this next time. ## Steps 1. **Apply learnings.** Accepted rules override the defaults (a different floor, a stage the reader never sends). Name each one that fires. 2. **Check the preconditions.** From the `tracking-audit` handoff or the export:    | Condition | Do |   | --- | --- |   | No stage has a date field | Stop at `NOT READY`; deliver the data contract (step 8) only |   | A platform's match key rate is under 50% | That platform is `NOT READY`; plan the others |   | Match key rate 50% to 79% | Plan it; open item to raise the rate |   | No platform or source column | Apply the volume test to all leads, label it `volume per platform not available`, and make each bid-on stage conditional on that platform's share of the volume | 3. **Write the stage ladder.** Lead created, then the reader's stages, shallow to deep. For each: entry rule, date field, value field, and whether sales can move a record back (a stage that can be undone is sent once, when first reached). 4. **Measure the timing.** Run the script on the export:    ```   python3 scripts/stage_timing.py --csv leads.csv --stages "mql=mql_date,sql=sql_date,opp=opp_date,won=won_date" \       --start-col click_date --platform-col source --amount-col amount   ```    Without Python, by hand: for each stage, list the days from the click date (or the lead's created date) to the stage date; sort them; take the middle value (median) and the value 9 in 10 fall under (p90); count the share at or under each platform's window from `references/platform-windows.md`; count stage events in the last 90 days and divide by 3 for a monthly volume, per platform. Drop rows where a stage is dated before the one above it, and count them. Say which way you ran it. 5. **Value the stages from the reader's own data.** Stage value = the share of leads reaching that stage that went on to close won, times the median won amount. Measure the share on a mature cohort only: leads that started at least the p90 days to closed-won before the export's last date, so open deals don't pull the rate down. Under 10 won deals in the mature cohort: write values as `not available` (one deal more or less moves the rate by 10% or more) and send stages without values. 6. **Pick the bid-on stage per platform.** Take the deepest stage that passes both tests:    | Test | Default | Why |   | --- | --- | --- |   | Inside the window | 80% or more of the stage's events happen within the platform's window | Below that, more than 1 in 5 events never arrive, and bidding learns from the deals that move fastest |   | Volume | 15 or more events a month on that platform, or the platform's own published minimum where it has one (Meta Conversion Leads: 200 leads a month) | At 15 a month, chance alone moves a month by about 8 either way, so a smaller stage can't show a real change |    Then handle the gap between the sales cycle and the window:    | Situation (first match wins) | Plan |   | --- | --- |   | The opportunity or closed-won stage passes | Bid on it. Send the earlier stages as secondary conversions for reporting |   | A deeper stage fails the window, an earlier one passes | Bid on the earlier stage with its stage value. Send deeper stages as secondary inside the window; report the share lost |   | Only the lead stage passes, and `lead-scoring` returned READY | Offer a predicted stage: send leads graded A as their own conversion at creation, valued by grade A's won rate from the scoring hold-out. This is a `NEEDS DECISION` |   | Only the lead stage passes, no READY score | Bid on leads; send deeper stages as secondary; say plainly that this platform can't learn pipeline yet |   | Nothing passes the volume test | Send every stage as secondary for measurement; bid on the platform's lead event; revisit when volume grows |    For Meta, Conversion Leads applies only to Instant Forms leads; website leads go through the Conversions API as measurement. 7. **Write the spec per platform.** One table per platform: conversion action name (the CRM stage name, so reports and bidding read the same word), type (LinkedIn: the rule type, such as `SALES_QUALIFIED_LEAD`; Meta: the CRM event for Conversion Leads; OpenAI: `lead_created` or `custom` with a `custom_event_name`), primary or secondary, value rule, identifiers sent, deduplication ID, upload path (the CRM's native integration, Data Manager, an automation tool, or the API), frequency, the window setting, and consent fields. Platform specifics: `references/platform-windows.md`. 8. **Write the data contract.** The CRM fields the plan needs: each platform's click ID on the contact, copied to the opportunity when it is created; a date field per stage; the won amount; consent state where the regions need it. Hash email and phone at upload, never before storing them in the CRM. 9. **Check the plan** (the loop below), then hand over. ## Check and verdict Checks on the plan: | ID | Passes when || --- | --- || L1 | Each bid-on stage has 80% or more of its events inside that platform's window || L2 | Each bid-on stage meets the volume test || L3 | Each platform has 1 primary conversion per real event; deeper stages are secondary || L4 | Every value shows its inputs (stage-to-won share, median won amount, cohort size) from the reader's data || L5 | Every identifier the spec sends is in the data contract, and the platform's match key rate is 50% or more || L6 | Upload frequency is at least daily where the event age limit is 7 days, and never longer than any limit || L7 | Where the regions include the EEA, the UK or Switzerland, uploads carry consent; only hashed personal data leaves the CRM || L8 | Every window and limit cites its page and the date checked, and the date is under 90 days old || L9 | Each event carries the date the stage happened, and stages that can be undone are sent once | | Verdict | Condition (first match wins) || --- | --- || `BLOCKED` | No lead or stage data of any kind (no export, no report) after asking || `NOT READY` | The CRM holds no stage dates, or every platform in scope has under 50% match keys: fix tracking first and deliver the data contract || `NEEDS DECISION` | 2 plans are both viable and trade depth for volume (a deeper stage near the floor against a shallower one with several times the volume), or a predicted stage is on offer || `READY WITH GAPS` | The plan passes L1 to L9, and a platform loses deeper stages to its window, or coverage is partial || `READY` | The plan passes L1 to L9 for every platform with full coverage | Named stops: `BLOCKED` asks for the export. `NEEDS DECISION` shows both plans side by side: stage, monthly volume, share inside the window, the value used, and what each teaches the platform. No other stops. ## Loop 1. Run L1 to L9 on the plan.2. Fix each failure: L1 or L2, move the bid-on stage up 1 level; L4, drop the value or show its inputs; L5, add the field to the data contract or mark the platform `NOT READY`; L6, raise the frequency; L7, add the consent field; L8, re-read the page or mark the figure `to re-check`.3. Check again. At most 2 rounds, then hand over with what still fails, labelled. ## Learn - The reader picks a plan at `NEEDS DECISION`: write the choice and reason as a `fact`.- 60 to 90 days after launch, the reader reports what changed (opportunities from the platform, cost per opportunity): write a `fact` with the figures and the CRM report as source.- The reader changes a default (floor, the 80% test): write a `proposal`.- A platform window changed since the reference date: write a `fact` with the page and the new figure. Example: `- 2026-10-24 | crm-feedback-loop | fact | LinkedIn bids on SQL (365-day rule), Google on MQL with stage values | Why: reader chose at NEEDS DECISION, sales cycle 74 days median | Status: noted` ## Output ```Verdict: <READY | READY WITH GAPS | NEEDS DECISION | NOT READY | BLOCKED> · Coverage: <complete | partial (what's missing)> · Timing: <script | by hand> · Windows checked: <date> Stage timing (days from click):| Stage | Events | Median | p90 | Inside: Google GCLID 90 / ECL 63 / LinkedIn 365 / Meta 28 / OpenAI 30 | Per month by platform | Stage-to-won (cohort) | Value | Plan per platform:| Platform | Bid on | Secondary | Value rule | Identifiers | Upload path, frequency | Window setting | Share of deeper stages lost | Spec: <one table per platform, step 7>Data contract: <fields to add or fix>Checks: L1 to L9 pass or fail, with the round they passed inGaps: <what the windows lose, by stage and platform>Learnings applied: <list, or none>``` Then the handoff block. ## Hand off ```handoffskill: crm-feedback-loopversion: 1.0.0verdict: READY WITH GAPScoverage: partial (no Meta Instant Forms leads)for: <company> paid platformsoutputs:  bid_on: {google: mql, linkedin: sql, openai: lead}  values_from: mature cohort of 214 leads, median won amount from CRM  lost_to_window: {google: {won: 0.71}, openai: {sql: 0.64, won: 1.0}}  fields_to_add: [oppref, li_fat_id on opportunity]  windows_checked: 2026-10-24next: [tracking-audit, pipeline-report]open: [confirm LinkedIn rule type supports 365 days]``` `tracking-audit` runs again after the build to check the imports. `pipeline-report` reads `bid_on` to note which stage each platform was optimizing for. ## Failure modes | Problem | Do this || --- | --- || The export has lead created dates but no click dates | Use the created date and say windows are measured from the lead, which runs a few days later than the click || Stage dates are overwritten when a record re-enters a stage | Use the first date; if only the latest exists, say timing is understated || The reader asks what match rate or conversion rate to expect | There is no such figure here; the plan uses their own data and the platforms' limits only || A platform's page has changed since the reference date | Use the current page, cite today's date, write a `fact` learning || The sales cycle differs a lot by segment (deal size, region) | Run the timing per segment and plan the bid-on stage per segment's campaigns || The reader asks the agent to set up the import | Decline: this skill writes the spec. Point to the platform's own integration or the person who owns the account | ## Influenced by - Google's documentation on enhanced conversions for leads and offline conversion imports, including the 90-day and 63-day upload limits: https://support.google.com/google-ads/answer/15713840?hl=en- LinkedIn's, Meta's and OpenAI's conversions API documentation, for their windows and event age limits (links and dates in `references/platform-windows.md`).- SHAKEUP's MarkOps practice: bid on the deepest stage the window allows, value earlier stages with the company's own conversion rates, and say what each platform can't see.

How it thinks

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

What we built

We bid on the deepest stage each platform's window allows and value earlier stages with your own stage-to-won rates. Every window comes from the platform's own documentation with the date it was checked, and the plan says plainly what each platform can't see.

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

    A floor, a stage you never send or a choice made last time changes the defaults before it starts.

  2. 02

    Check the preconditions

    No stage dates, or fewer than half of a platform's leads with a match key, and that platform isn't ready. It writes the data contract instead.

  3. 03

    Measure each stage against each window

    Its script counts how long each stage takes after the click and what share lands inside each platform's window, read from the platform's own pages with the date checked.

  4. 04

    Value stages from your own data

    A stage's value is the share of leads at that stage that closed won, times your median won amount, measured on leads old enough to have closed.

  5. 05

    Pick the stage each platform bids on

    The deepest stage with 80% of its events inside the window and 15 or more a month on that platform. Deeper stages go in as secondary conversions.

  6. 06

    Write the spec and check it

    Conversion names, types, identifiers, upload path and frequency, consent, all checked against 9 rules, at most 2 rounds.

What you need

  • Required

    Leads with the date they reached each stage, platform or source, and won amount

    A connected CRM, read-only → A CSV export with date-entered properties → A stage timing report you paste

  • Required

    Your stage names and what moves a record into each

    Your CRM settings → Your answer

  • Optional

    The tracking audit result

    The tracking audit's handoff block → Click ID columns in the export

  • Optional

    Each platform's current window settings

    A connected ad account, read-only → Screenshots or your answer

What it can return

  • READY

    The plan passes every check for every platform, with full data.

  • READY WITH GAPS

    The plan passes, and a platform loses deeper stages to its window or some data is missing.

  • NEEDS DECISION

    2 plans both work and trade depth for volume, or a predicted stage from lead scoring is on offer.

  • NOT READY

    Stages carry no dates, or no platform has enough leads with a match key.

  • BLOCKED

    No stage data can be provided.

Where it stops for you

  • When no stage data can be provided
  • When 2 plans both work and you need to choose between depth and volume

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 with a sales cycle of about 2 months. Google Ads and LinkedIn Ads bid on demo requests, and sales rejects most of them.

Verdict

READY WITH GAPS

Coverage: complete

Timing: script

Windows checked: 2026-10-24

StageWithin Google's 63 daysLinkedIn, within 365 daysGoogle a monthLinkedIn a monthValue
MQL95%100%4035$2,400
SQL82%100%2018$4,560
Opportunity69%100%1516$6,000
Closed-won25%100%33$24,000

Google Ads bids on SQL, valued at $4,560 from the company's own cohort. Opportunities and closed-won go in as secondary conversions, and the plan names what the 63-day limit loses.

LinkedIn Ads bids on opportunity, through a lead-type rule with a 365-day window. Closed-won stays secondary at 3 a month, under the floor of 15.

The handoff block the next skill reads
skill: crm-feedback-loop
version: 1.0.0
verdict: READY WITH GAPS
coverage: complete
for: Google Ads and LinkedIn Ads
outputs:
  bid_on: {google: sql, linkedin: opportunity}
  lost_to_window: {google: {opportunity: 0.31, won: 0.75}}
  windows_checked: 2026-10-24
next: [tracking-audit, pipeline-report]
open: [confirm the LinkedIn rule type supports 365 days]

What good looks like

  • One bid-on stage per platform, with the share of it inside the window
  • Stage values that show their inputs from your CRM
  • Deeper stages sent as secondary, with what each platform loses named
  • Every window cited with a link and the date checked
  • A data contract your CRM admin can build from

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.

Does it set up the imports?

No. It writes the spec your team or partner builds, and it reads accounts only through read-only connections.

What if our sales cycle is longer than the platform allows?

It bids on the deepest stage that still lands inside the window, valued by your own rate of reaching closed-won from that stage. Deeper stages are sent for reporting, and the plan names the share each platform can't see.

Where do the windows come from?

From each platform's own documentation, listed with links and the date checked. If that date is more than 90 days old, the skill reads the pages again before planning.

Does it need Python?

No. The script counts stage timing from an export. Without it, the skill does the same count from a timing report and says which way it ran.