Every decision in a go-to-market pipeline is training data

every step of a go-to-market pipeline is a decision. which post counts as a signal, which lead goes first, which play to run, which draft ships.

every one of those decisions is training data. but only if it's recorded in the right shape from the first day. recompute it later and it's useless. throw away the "no" answers and you can't train anything.

this week i mapped all 12 stages of the pipeline i'm building into vibedraft, wrote down what each one has to record, and checked it against my own code.

the pipeline in one line

link → brief → ICP → trigger → detector → signal → lead → playbook → campaign → sequence → funnel → loop

four phases: understand the product, find who's ready, reach them, learn what worked.

the 8 rules

1. log the decision, not just the result. every choice, by the system, by me or by the lead, is an append-only event that names who made it.
2. version whatever decided. model, prompt, rule, scorer, ICP, detector. every row carries the versions that produced it.
3. freeze the inputs. store the features as they were at decision time. recompute them later and you leak the future into your training data.
4. keep the negatives. discarded matches, skipped leads, blocked sends, "no" replies, each with a reason. they're half of every training set.
5. log the odds. store the probability of each choice and keep a small random slice, so a new model can be judged on old data before it ships.
6. every human touch is a label. edits, corrections, skips, never-contact marks. the before, the after, and the reason.
7. one chain of ids. detector, signal, person, lead, move, touch, account, payment. any payment traces back to the rule that found the person.
8. keep the raw, with a retention rule. full text, the url, and both timestamps: when it was posted and when it was captured.

what each stage records

understand the product

• link: each intake step reached, with timestamps, and where people leave. trains: which intake and copy finish more briefs.
• brief: every field with its evidence level and the quote behind it, plus my corrections as a before and after. trains: an eval set for the extractor, and whether strong evidence really means right more often.
• ICP: which fit lines each lead matched, frozen. trains: which lines actually predict payment, so the weak ones get cut.

find who's ready

• trigger: the post's own timestamp next to when it was caught. trains: how fast each trigger goes stale.
• detector: version, run cost, and shadow verdicts next to live ones. trains: precision and yield per dollar for every watching rule.
• signal: the raw text frozen at capture, the judge's verdict and confidence, and every discard with its reason. trains: the match judge.
• lead: the score with the exact features used, frozen. trains: who actually replies.

reach them

• playbook: every play the lead was eligible for, the one chosen, and its odds. trains: which play to run, judged offline before it goes live.
• campaign: the arm each lead was in, including a holdout that gets nothing. trains: real lift instead of correlation.
• sequence: every draft, what i changed, and how long i took to decide. trains: a reward model built from what i actually post.

learn what worked

• funnel: every rung reached with its timestamp, and each post's metrics at 10 minutes, 30 minutes, 1 hour, 1 day and 7 days. trains: conversion, churn, and an early read on which posts will land.
• loop: every change, the rule to judge it, and the result. trains: priors for the next test.

the 13 training sets this produces

brief corrections, match labels, discards, lead reviews, scored leads, moves, drafts, preference pairs (a draft next to what i actually posted), post snapshots, campaign arms, account days, saves, and experiments.

none of them needs extra work. each one is a by-product of running the pipeline, as long as the stage is recorded in the shape above.

what my code already does

• the draft log records the prompt version, a randomized slot, the variant, whether i shipped, edited or discarded it, the edit distance, which part i rewrote, and how long i took to decide.
• every post's metrics get snapshotted at 10 minutes, 30 minutes, 1 hour, 1 day and 7 days.
• new detectors run in shadow before they go live.
• briefs keep an evidence level on every fact, and my corrections are never overwritten.

what it's missing

• an id on every message i send to a lead. without it, nothing after "sent" can be learned. this is first.
• the odds behind each next move, plus a small random slice.
• discarded matches kept as rows. right now the "no" answers disappear.
• a holdout in every campaign. without one, every result is a correlation.

experiments run on top of this

every stage has a knob: the judge prompt, the scorer weights, the opener, the offer, the send time. listen-side changes can be replayed over stored data with no live risk. act-side changes need real randomization with logged odds. campaigns need a holdout. every readout goes into a learnings table, win or lose.

why bother this early

my waitlist is tiny right now. that's exactly why. the data you didn't record in month one is the model you can't train in month six.

i'm building all of this into vibedraft: it finds people asking for what you built and drafts the messages. you send every one.

if you want a pipeline that records all of this for you, the waitlist is open at vibedraft.app.