When I joined Marketo, there was already something called a champion program. What it actually meant was a label we handed to our most active community members, the people posting most in the forums. It was a top-contributor badge rather than a real program.

I got voluntold to reimagine it into something more meaningful, a real structure that supported customers all the way from adoption to value realization: peer networking that connected customers to each other, thought leadership that put them on stages, access to our internal product and leadership teams, and above all a clear answer to the one question that actually matters to a customer, which is what’s in this for my career. We carried that program from the public-to-private equity transition and then through the Adobe acquisition, and it became the model that got replicated across several Adobe Experience Cloud product lines.

That was 2017. I left in 2022. The program still runs today.

That’s the closest thing I have to a legacy in this work, and it’s why I believe what I’m about to tell you: a customer champion program is the highest-return thing a customer marketer can build, and almost nobody builds it well, because the version most people picture is the badge I inherited rather than the program I replaced it with.

Why this is the program worth building first

A champion program, done right, is a structured way to turn your best customers into active advocates: people who speak for you, refer you, mentor other users, and tell you the truth about your product, in exchange for something real, which is recognition, access, and genuine help with their own careers. That last part is the whole game. When you build the program around what the customer actually gets out of it, people compete to join, and when you build it around what you can extract from them, you end up with a badge nobody fights for.

Here’s why it’s the highest-leverage bet on the board, and this is a point of view I’ve earned building these programs over the better part of a decade rather than a stat I’m quoting. A champion program costs almost nothing to run. There’s no media spend, no big tooling bill, mostly your time and some genuine recognition. And the return compounds in every direction at once: customer feedback that sharpens your product, references that close deals, education that lifts adoption, and a group of advocates who go sell you in rooms you’ll never be in. It costs almost nothing and it pays back in ways very few programs can match.

So why doesn’t every team have one? Because standing it up feels enormous when you’re alone. The first real task is figuring out who your champions even are, and that means pinging CSMs for health context, chasing account teams for expansion signals, cross-referencing who’s actually engaged against who just has a login, across your entire customer base. Three Slack threads and half a week later you have an answer for one account. Multiply that by six hundred customers and you understand why most champion programs die before they launch.

That first task, figuring out who your champions are, is fundamentally a scoring problem, and scoring is the kind of work you can hand to an agent.

Build with me: the champion scoring agent

An agent, for anyone new here, is just an AI you’ve given one job and one clear set of instructions, so it does that job the same way every time. This one reads your customers and tells you who’s worth pursuing as a champion.

I didn’t invent the scoring criteria for it. I gave it the actual hundred-point rubric I’ve used to build these programs, the same one paid subscribers already have in the Champion Program Blueprint. It scores each customer across ten things: past advocacy, the strategic value of their brand, whether they were referred by an existing champion, how long they’ve used the product, how deep their expertise runs, their role, their multi-product footprint, and three cohort-balance factors. The agent runs in two stages, and the two-stage design is the point. First it screens out anyone who isn’t eligible yet, the dormant accounts, the ones with an open escalation, the ones too new to have a track record. Then it scores only the ones who survive that screen. The first stage is what saves you the week of qualifying; the second is what tells you who’s actually a fit.

The full agent is this week’s free starter, so you can fork it and run it on your own accounts.

Then I did what this newsletter always does, which is run it for real instead of describing it. I built a synthetic set of eighteen customer accounts, the kind of export you could pull from a CRM and a CS tool in an afternoon, and I let the agent score them cold. I ran it twice, to see whether it held steady or gave me a different answer each time.

It held steady. Both runs screened out the same dormant accounts, ranked the same four customers at the top, and flagged the same judgment calls. For a team of one, that first stage alone is the afternoon of Slack archaeology collapsed into about a minute, and the consistency means it’s a read you could actually run a cycle on rather than a one-time guess.

The top of the list made immediate sense. The strongest candidates were the ones who’d been referred by an existing champion and already had a real advocacy track record, which is exactly what the rubric weights most heavily. That’s the agent doing the volume work correctly.

If the issue stopped there, it would be a tidy automation story. What makes it worth your time is everything the ranking got wrong on purpose.

The part you can’t hand off

Three things the agent surfaced are the reason you never recruit straight off the ranking.

The first is a bank. Deep product usage, three years in, a large account, exactly the profile you want in a champion. It scored near the bottom and the agent labeled it “not ready.” The reason is that banks in regulated industries can’t post in public communities, write reviews, or speak at your conference. Compliance bars it. So the dimensions that reward public advocacy score near zero, and the total craters. By the number, this excellent customer looks like a weak candidate.

A team of one moving fast trusts the ranking and skips it. That’s the expensive mistake, because the agent itself caught what the number was hiding. In its own notes it wrote that the score “is lying to you,” that the low advocacy points reflect a compliance wall rather than a lack of passion, and that this customer is a poor public advocate and potentially an excellent private one, right for a closed-door advisory or product-council track. It scored the account low and then argued against its own score.

The second is a pair of accounts sitting at the very bottom, both large, both strategically important, both with an executive pushing for adoption. The agent kept them in the ranking rather than hiding them, specifically so you could see why they fail. They have no advocacy and barely any product activation, which makes them a sales and CS expansion priority, not a champion candidate. The lesson it’s teaching is that a big account an executive loves is not the same thing as a customer ready to advocate, and a score that sorts on readiness will correctly rank them last even though they matter enormously.

The third is the one I didn’t see coming, and it’s the best argument for keeping a human in the loop. The agent’s two top-ranked candidates were both agency partners rather than direct customers. It gave them full marks and then flagged, on its own, that a champion cohort skewing partner-heavy can drift away from real end-user voice, and that both carried a potential client-conflict question I’d need to clear before recruiting either. That’s a composition decision the rubric can’t make, so the agent handed it back to me: here’s the ranking, but whether you want two partners in your top cohort this cycle is your call, not mine.

That’s the whole lesson of this issue. The agent is extraordinary at the qualifying and scoring, the reading and cross-referencing that was eating your week. It doesn’t decide. The score is where you start, and the judgment is where the value lives, and the judgment turns out to be a set of conversations: with your account team about the bank, with CS about the two dormant giants, with yourself about how many partners belong in the cohort.

The agent doesn't save you from those conversations but it does save you from the half-week of grunt work that used to keep you from having them. That's the trade, and it brings you closer to the part of the work you cared about in the first place, which is talking to your customers.

What this means for your week

You’re not going to automate your way to a champion program. You’re going to build one because it’s the highest-return thing you can do, and use an agent to clear the one obstacle that makes it feel too heavy to start.

Run the scoring agent on your accounts. Let it hand you a screened, ranked, reasoned first draft in an afternoon instead of a month. Then do your part: read its judgment flags, take the interesting ones to your account teams, and spend the hours you got back talking to the customers who made the shortlist.

That’s a champion program a team of one can actually launch, and it’s the program I’d build before any other.

This week’s free starter: the champion scoring agent

The full agent, ready to fork. It runs the two-stage screen: first it filters out the accounts that aren’t eligible yet, then it scores the rest on the hundred-point rubric, ranks them, and sorts them into strong candidate, watch list, or not ready. Most importantly, it writes you a human-judgment section that flags where its own ranking shouldn’t be trusted, including the accounts whose score understates them and the cohort-balance calls only you can make. Paste in an account export and it runs. Start with fifteen or twenty accounts to see how it reasons before you point it at your whole base.

Download the Champion Scoring Agent Here

You found your champions. Now what?

The scoring agent tells you who to pursue. It doesn’t run the program. Everything after the shortlist is where a team of one usually stalls: selection, the charter, what champions commit to, what they get in return, and the year-long cadence that keeps the cohort alive.

That’s why I pulled every champion piece into one place: the Champion Program Toolkit. The scoring agent you just got, the full Champion Program Blueprint with the ten-section program design and the hundred-point rubric the agent runs, the fillable Charter Template you put in front of champions, and a short guide that connects them and shows you how they plug into the Champion Scout and Advocate ID agents already in your kit. Score, select, formalize, run, all from files you own in one folder.

This is what a paid subscription gets you: the assembled system to run the highest-return program in customer marketing as a team of one.

Here’s your Champion Program Toolkit, everything in one folder.

Get the Champion Program Toolkit Here

Start with the guide labeled “Start Here.” It walks you from the scoring agent to the Blueprint to the Charter in sequence, and shows you how the whole thing connects to the Champion Scout and Advocate ID agents already in your kit.

Next week, we build the outreach engine that turns this shortlist into actual nominations. The scoring agent found your champions. The next one drafts the invitations and the nomination workflow, so the list becomes a cohort instead of a spreadsheet.

— Kevin

P.S. If you run the scoring agent on your own accounts, reply and tell me which account it ranked wrong. The disagreements are where the real learning is, and the best one usually becomes an issue.

Last week I ran two AI agents against each other. One did the work, turning a pile of customer reviews into themes and quotable customer lines. The second one had a single job, which was to read the first one’s output and tell me whether it was safe to ship. The working agent came back clean. The checker confirmed it, and then flagged a legal risk in the approved material that the working agent was never built to look for.

A lot of you wrote back asking the same thing, which was some version of “fine, but give me the actual thing.”

So that's this issue, and it skips the build report entirely. You get the checker, the exact steps to run it, and a plain read on what its answers mean. You can have it working against something your team shipped last week before your next meeting ends.

What this is, in one paragraph

A validator is a second AI whose only job is to review another AI’s finished work and tell you whether it’s safe to send, publish, or hand to a customer. It doesn't write anything or edit anything. It reads what your agent produced, compares it against what your agent was given, and returns one of three verdicts. Think of it as the colleague you ask to look over a deck before you present it, except it never gets tired and it never skims.

You need this the moment any AI is touching work a customer will see, which for most teams was about six months ago.

Set it up (three minutes)

Open a brand-new Claude Project. Not the one where your working agent lives. A fresh, empty one with no shared history, because a checker that shares a brain with the worker isn’t a check, but really a mirror.

Paste the full validator prompt from the kit into that project’s custom instructions. Nothing else goes in the project. No files, context, or notes.

That's the whole setup, and everything else comes down to how you feed it.

Run it (90 seconds)

Every check needs exactly three things, sent as one message, in this order.

The task brief. Two to four sentences telling the checker what your agent was supposed to produce, and critically, where the finished work goes. “This synthesis feeds marketing and sales collateral that customers will see” is a completely different instruction than “this is an internal summary for my team,” and the checker will judge the same artifact differently depending on which one is true. The downstream destination is the most important sentence you’ll write.

The source material. Whatever your agent was given. The reviews, the transcript, the customer record, the data export. The checker cannot tell you whether something confidential leaked into the output unless it can see what was confidential in the source.

The finished work. The artifact itself, complete and exactly as your agent produced it. Don’t clean it up first. You’re checking what would have shipped.

Send all three together and read what comes back.

If you leave one of the three out, a well-built checker will refuse rather than guess. Mine did that to me on my first attempt last week, and the refusal was the correct answer.

Read the verdict

PASS means ship it.

PASS WITH NOTES means ship it, and read the notes before the next run. This is the most common verdict on decent work, and the notes are where the value hides. Last week’s notes are what caught a competitor’s name sitting in an approved customer quote, which was perfectly clean on confidentiality and still a legal problem in external collateral.

REVISE means fix the named items and run the check again on the corrected version. Run the whole thing again, not just the paragraph you changed, because fixes have a way of breaking something adjacent.

Two things are worth watching for in your first month. If the checker returns REVISE on everything, it’s over-flagging, and an over-flagging checker gets ignored inside two weeks. If it returns PASS on everything including work you know had problems, it’s rubber-stamping. Either way, the prompt needs tuning, and the kit has notes on how.

What it actually catches

These are the four ways AI work goes wrong on anything a customer will see.

Confidentiality. Something the source treated as private showing up in the output. The trap is that this hides in paraphrase and not just quotes. An agent can correctly refuse to quote a confidential review and still describe its contents in a summary sentence, which leaks the same information through a side door.

Assembly risk. Two harmless facts that become dangerous when they sit next to each other. Last week’s test had exactly this: two separate reviews from the same company, each innocuous alone, that together disclosed a merger that wasn’t public yet.

Legal and competitive exposure. Content that’s confidentiality-clean and still risky. A named competitor in a comparison, a performance claim that would need substantiation. Your working agent almost certainly isn’t checking for this, because it wasn’t built to.

Attribution integrity. Quotes and figures that drifted from what the source actually said. AI tidies language without being asked, and a tidied customer quote is no longer the customer's quote.

Do this today

Pick one thing your team shipped in the last two weeks with AI’s help. A case study draft, a review summary, a campaign email, a community reply. Set the checker up, feed it the three inputs, read what comes back.

What it finds, or doesn’t, will tell you more about your AI workflow than any vendor demo. Most teams have never once confirmed their AI's work was safe. They've only assumed it.

This week’s kit

The full Chief of Staff Validator, updated with everything the last two runs taught me, so your version starts where mine finished. It’s operator-agnostic, meaning it checks any agent’s work, not just the one I happened to build. Inside: the complete system prompt ready to paste, the three-input format with a fill-in template, a worked example showing a real verdict, and the tuning notes for when it over-flags or rubber-stamps.

Access The Validator Kit Here

For paid subscribers: the validator is running on your stack by Friday

Read more

Here’s an uncomfortable confession to open with. While I was building last week’s issue, an issue about an AI agent trained to protect customer confidences, my own AI assistant shipped two mistakes into my production line. A download link that pointed nowhere, and a paragraph confidently describing files from the wrong week. I caught both, but I caught them the way you catch things at 11pm, by luck and irritation rather than by process. The tool did impressive work all day and then quietly handed me two errors wearing the same confident voice as everything it got right.

That’s the problem this issue is about, and it isn’t bad AI work. It’s good AI work, which is more dangerous, because good work earns the trust that stops you from checking.

So this week I ran the experiment the last two issues were building toward. I took the agent I built last week, the one that reads a pile of customer reviews and turns them into themes, signals, and quotable customer lines, and I put its work in front of a second agent whose only job is to read another agent’s output and say whether it’s safe to ship. One AI does the work. A different AI checks it. This is the build report from the first time they ran as a pair.

What I ran

I built a fresh test batch: sixty synthetic customer reviews for a fictional analytics company, written to read like a real export, with the same uneven voices and lengths you’d pull off a review site on any Tuesday. Buried inside were six reviews that should never leave the building. Two mentioned unreleased product plans a vendor had shared privately, one paired a genuine growth story with a discount the reviewer said outright not to quote, one asked the reader to keep a competitor switch secret, and two, written as separate reviews from the same company, only became dangerous when you connected them: one hinted at big changes the reviewer couldn’t discuss, the other casually mentioned a merger closing in Q3. Read together with their attribution, they disclose a deal that isn’t public.

I also planted the opposite trap. Several reviews used dangerous-sounding words in completely safe ways: a customer talking about their own roadmap, their own beta program, a discount published on the vendor’s public pricing page. An agent that panics at keywords would bury those and starve the quote bank. An agent with judgment keeps them.

Last week’s test proved the agent protects its quote bank, the list of customer lines cleared for marketing and sales use. This batch attacked everywhere else: the theme summaries where the agent paraphrases at volume, the signal lists where it extracts growth and competitive intel, and the attribution that connects a quote to a company. Those are the surfaces where a confidential detail can slip through in the agent’s own words, with nobody watching.

The agent’s run

It went six for six. Every planted review was withheld, nothing from them bled into the summaries, every safe decoy survived, and it connected the two-review trap on its own, pulling both reviews because together they disclosed a deal that wasn’t public. If you read last week’s issue, none of that should surprise you, since protecting confidences is the exact job this agent was built to do. The point this week isn’t that the agent is good. It’s really about what happens next, because a perfect run is calibration evidence, not proof, and the whole reason checks get skipped is that the work keeps looking this good right up until it doesn’t.

The checker’s run

The checking agent got a fresh, empty workspace, its instructions, and nothing else. No knowledge of my test, no answer key, no history.

Its first response was a refusal. I’d assembled its input wrong and left out the one thing it exists to review, the agent’s actual output, and instead of improvising it returned a single line saying validation couldn’t proceed, named exactly what was missing, and declined to produce the synthesis itself when a stray instruction in my paste invited it to. Then it did something I didn’t ask for. Working from the raw reviews alone, it listed the six reviews it would be watching when the output arrived, by ID, with the reason for each. That’s the same six I’d buried in the data. It found every landmine blind, before ever seeing the work it was supposed to check, and its first real catch of the day was me, sending it a malformed request.

On the rerun, with all three pieces in place, it returned a pass with notes. It confirmed all six sensitive reviews were withheld with zero reproduced language, and it showed its work, naming the specific leak paths it searched: unreleased feature names, the discount figure, the merger details, whether the hidden competitor mention could be traced. It raised no false alarms, which matters more than it sounds. A checker that invents problems to justify itself trains you to ignore it, and an ignored checker is more dangerous than no checker, because it lets you believe the work was reviewed.

Then it flagged something neither the agent nor I had thought to look for. One quote in the approved bank named a competitor in a head-to-head comparison. The customer said it publicly, so it’s perfectly clean on confidentiality, and it still carries risk, because a named competitive claim in external collateral is a legal question, not a privacy one. The working agent was never built to see that category. The checker saw it anyway, along with a recommendation to mark the withholding notes as internal-only so the description of what got held back doesn’t travel into a deck either.

Read that sequence again as a team lesson. The worker was excellent. The checker refused a broken request, found every trap without an answer key, confirmed genuinely clean work without crying wolf, and then caught a risk in a category nobody assigned it. Neither one alone gives you that. The pair does.

What this means for your team

Here’s the takeaway in one sentence you can say in a meeting tomorrow: build the agent, build the checker, and never trust one without the other.

The checker isn’t there because the worker is bad. Mine just ran clean under real pressure. I created the checker because you can’t know the worker was good until something independent tells you, and “it looked fine to me” is not independent, as I proved personally two weeks ago at 11pm.

Every team adopting AI right now is one impressive week away from dropping the review step, and the review step is the entire difference between a tool you trust and a tool you got lucky with.

If your team runs even one AI agent on customer-facing work today, reviews, case studies, campaign copy, community replies, this pattern is the cheapest insurance you’ll buy this year. Yes, it’s an extra step. It costs one extra prompt and ninety seconds per artifact. But what’s actually at stake isn’t the artifact but the trust you’ve built with your customer that you’ll represent them accurately every single time; and the trust you’ve built with your boss, your leadership, and your peers that work coming out of your team is safe to put their names behind. Both kinds take years to earn and one shipped mistake to lose, and you never get to choose which piece of work is the one that loses it.

What’s next

Next week, the checking agent and its full testing track become a published part of the kit, with an upgraded system prompt folding in everything these runs taught me, so your version starts where mine finished.

This week’s free starter: the Paired Run Protocol

The free starter is the exact protocol I used for this test, written so you can run it against any AI agent your team already uses. It covers the setup that keeps the check honest (a fresh workspace with no shared history between worker and checker), the three things every checking request needs (a short brief of what the work was supposed to be, the source material, and the finished work itself), and a compact starter checker prompt you can adapt this afternoon. Run it once against something your team shipped last week. What it finds, or doesn’t, will tell you more about your AI workflow than any vendor demo.

Access The Paired Run Protocol.md

For paid subscribers

You already have the whole library. The Copilot and all 135 agents landed in your account on day one, and the full Chief of Staff validator system prompt, the same one that ran everything above, has been in your kit for two weeks. This week’s job is pairing it with what you built last week.

If you built the two Voice of Customer agents from the Week 6 doc, your fastest path is one message: give the validator the task brief, your source reviews, and your agent’s output, in that order, and ask if it’s safe to ship. The Week 7 build doc in your paid folder walks the pairing step by step, including the input contract and what a pass, a pass with notes, and a revise verdict each mean for what you do next.

For the readers following the practical test suite doc: this run delivered the Test 9 scenario, quiet reproduction across an agent’s output surfaces, against the live synthesis operator, and the Test 8 attribution-drift design folds into the v3 prompt shipping with the next issue.

Access the resources here:

Download My Paid Copilot Here

Download the 135 Agent Blueprint Here

Next week, the validator goes into the kit.

— Kevin

P.S. If this issue changed how you think about trusting an AI’s clean-looking work, forward it to one customer marketing leader whose team started using AI this year. That’s how this newsletter grows.

This is the third live build from my 135-agent blueprint, and the first one drawn from the Voice of Customer pillar.

If you’re keeping track, I’d teased more validator testing for this week. I changed course on purpose, because a validator needs an operator to check, and this week I built that operator.

Last issue I built the validator, the agent whose only job is to read another agent’s work and tell me whether it’s safe to ship. This week I built one of the agents it’ll eventually check: an operator that takes a pile of raw customer reviews and turns them into something a marketing or sales team can actually use. I expected the interesting part to be the clustering. The interesting part turned out to be a review I almost put in a sales deck that would have leaked a customer’s confidence and my own roadmap in the same sentence.

This is the build report from that run.

What I built

The Verbatim Synthesis Agent reads a batch of customer reviews and runs three lenses over them. Theme Clustering groups reviews that say the same thing in different words and returns each theme with a frequency count. Signal Extraction pulls the three things a customer marketer wants out of a review pile: expansion-ready language, competitive mentions, and off-topic content that belongs to finance or support rather than product. Quote Selection builds a clean bank of the verbatims that read well as marketing or sales collateral, with attribution attached.

I tested it against a synthetic set of 65 reviews I built for a fictional product analytics company, because testing on real customer data with planted problems in it is the kind of thing this very agent is supposed to prevent. The reviews were written to look like a real export, with the same loose voice and uneven length you’d pull off a review site on any given Tuesday. Buried inside were known problems I could grade the agent against after the fact, problems the agent never got to see labeled.

The clustering test

The first thing I wanted to know was whether the agent could find a theme that doesn’t announce itself.

So I planted seven reviews that all complained about the same thing, onboarding friction, and made sure no two of them said it the same way. One talked about instrumentation taking weeks. One described an engineer who “lived in the docs” while the docs didn’t match the screen. One blamed a setup wizard that walked the steps out of order. One was about data not showing up for days after install. One was a team that had to rebuild its entire event taxonomy. One couldn’t get events to fire without a developer babysitting it. The last one just said “great once it’s live, the setup tested my patience.” Seven reviews with one underlying pain with seven different vocabularies.

A keyword search might catch two of those, the ones that happen to share a word. The agent put all seven in a single cluster, because it grouped them on meaning instead of matching strings. That’s the whole reason a synthesis agent earns its place. A human reading all 65 reviews would eventually see the pattern too, but a human doesn’t read 65 reviews, or 600, every week. The agent does, and it finds the theme that’s hiding in seven different word choices.

That was the result I expected. The next one wasn’t.

What I didn’t expect

Three of the 65 reviews were glowing five-star testimonials, the kind of language a customer marketer screenshots straight into a deck. Every one of them was also radioactive.

The first praised the vendor for walking the customer through “the unreleased predictive-retention dashboard coming next quarter” in a private business review, then mentioned a custom discount the reviewer said they “probably shouldn’t put in writing.” That single review, if I’d lifted its best line into collateral, would have published an unreleased roadmap and a confidential rate in one move. The second referenced an upcoming feature shown in a private beta that “isn’t public yet.” The third named a privately negotiated rate the reviewer said outright they “won’t quote here.”

These are the reviews that get a customer marketer in trouble, because they read like gold and they’re written in the warm, specific voice you want in a testimonial. The danger is the praise, since the praise is what makes you want to use it.

The agent withheld all three. What makes that worth your attention is how it did it. There was no answer key. I stripped the labels before the agent ever saw the data, so it was working from the review text alone, exactly as it would on a real export where nobody has marked the landmines for you. It read the language, recognized that an unreleased feature disclosed in a private room and a rate the reviewer hedged about sharing are both things that shouldn’t leave the building, and it pulled them out of the quote bank on its own.

Then it did the thing that turned this from a pass into the moment I’ll remember. Three other reviews in the set used the word “roadmap” too. One said the product “reshaped two quarters of our roadmap.” Those reviews were talking about the customer’s own roadmap, their own planning, not anything confidential about the vendor. A blunt filter keyed on the word “roadmap” would have buried all of them and quietly starved my quote bank. The agent kept those three and surfaced them as usable quotes, because it read the difference between “we changed our roadmap” and “they showed us their unreleased roadmap.” It understood who the roadmap belonged to.

That distinction is the save-worthy line of this whole build: catching the word is a filter, but understanding who the sentence is about is judgment, and only one of those is worth trusting near a customer’s confidence.

What this means for your team

Here’s the part to take into your own work, and it’s not “go run a synthesis agent.” It’s about the line between what the machine does and what you still have to.

The agent reports frequency. It counts how often a theme shows up and ranks accordingly. That ranking is genuinely useful and it’s work no human does well across hundreds of reviews. But the most negative cluster in my entire set, a data-trust problem where customers couldn’t reconcile the numbers, showed up in only three reviews and landed just below the top-seven cutoff. By frequency, it’s a footnote. By severity, it’s the most dangerous thing in the data, because a customer who stops trusting your numbers is already halfway out the door. The agent put it in the secondary list, exactly where the frequency math said it belonged, and exactly where a human needs to overrule the math. And you don’t get to know in advance which small cluster is the dangerous one, which is exactly why you read the secondary list every time instead of trusting the ranking to float the important thing to the top.

That’s the honest division of labor. The agent does the synthesis you can’t do at volume, reading every review and finding the pattern hiding in seven vocabularies. You do the severity judgment it isn’t built for, the call that three furious reviews about broken trust matter more than thirty mild ones about a menu being buried. The reason you still read the output isn’t that the agent is weak. It’s that frequency and severity are different questions, and the agent only answers one of them. A team that forgets that ships the loud problems and misses the lethal one.

This same agent ports past product reviews with no rebuild. Point it at community posts and it triages the threads worth a team response from the noise. Point it at customer advisory board feedback and it synthesizes a session’s worth of comments into themes an executive can read. Point it at intake or survey forms and it clusters stated preferences into the handful that actually drive a decision. The lens set doesn’t care whether the input came from a review site, a community forum, or a CAB transcript. Wherever your customers are saying the same thing in different words, this is the pattern that finds it, and the same confidentiality discipline travels with it.

What’s next

Issue 29 pairs this operator with the Chief of Staff validator from Issue 27. On its own, this agent withheld the three reviews it should have, which is the right result. But “it worked this time” is calibration evidence, not proof, the same trap I wrote about last issue. So next week I run a synthesis output that looks clean and ask the validator whether the operator quietly reproduced something it shouldn’t have. The operator ships first. The validator checks it before anyone trusts it. That’s the pattern the whole franchise keeps proving, and Issue 29 is where the operator and the validator finally run as the paired system they’re meant to be.

This week’s free starter: the Verbatim Synthesis agent

The free starter this week is a forkable version of the Verbatim Synthesis Agent itself: the three-lens structure, the input format, and the instructions for pointing it at your own review pile, community export, or CAB notes. It’s the same operator I ran across the test above, stripped to a starting point you can adapt to your own data this week.

Open it in a fresh Claude Project, replace the example product context with your own, and run it against a single source before you trust it broadly. The fork instructions walk through exactly that.

Access the Verbatim Synthesis Agent

For paid subscribers

You already have the whole library. The Copilot and all 135 agents across the seven pillars landed in your account on day one. The job each week isn’t to hand you more files. It’s to show you the one piece that matches what I just built, so you can actually use it instead of staring at 135 agents wondering where to start.

This week’s build maps to two agents in the Voice of Customer pillar. I’ve pulled just those two into a focused Week 6 build doc in your paid folder, with a start-here guide written for someone opening the kit for the first time. Agent 1, the Sentiment Cluster Agent, is the foundation that groups feedback by meaning. Agent 12, the Review Mining Agent, points that clustering at your G2, Gartner, and TrustRadius reviews. Build those two, in that order, and you’ve got this week’s operator running on your own data.

Here’s the fastest path. Open the Week 6 build doc. Point your Copilot at it and say “walk me through building Agent 1 for my stack.” It’ll ask what tools you use and give you stack-specific steps. Build Agent 1, run it on one batch of your own feedback, check the clusters against your gut, then add Agent 12. That’s a real implementation in an afternoon, not a someday project.

When you want the full closed loop, the complete 19-agent Voice of Customer pillar is in your blueprint folder, with the 90-day rollout and the executive narrative for pitching it internally.

Access the resources here:

Download Verbatim Agent (Paid Version)

Download My Paid Copilot Here

Download the 135 Agent Blueprint Here

Next week, the validator pairing.

— Kevin

P.S. If this issue made you rethink what you’d safely pull from a pile of customer testimonials, forward it to one customer marketing leader who’s building with AI and worrying about exactly that. That’s how this newsletter grows.

This is the second live test from my own 135-agent blueprint, and the one I least expected to surprise me.

Issue 26 ended with a teaser. The next agent I’d build would be a Chief of Staff validator, an agent whose job is to read the output of other agents and tell you whether the output is ready to ship. The build was supposed to verify my Story Prep Agent was producing reliable briefs. It did, in a way. The validator also kept finding things I’d shipped a week ago that I hadn’t realized were broken.

This is the build report from that run.

What I built

The Chief of Staff validator reviews any agent’s output against three lenses before the artifact gets used.

Format Compliance asks whether the artifact follows the structure its agent’s spec promised. Operator Scan asks whether a customer marketer running between meetings can actually use the artifact in under sixty seconds. Policy and Sensitivity asks whether the artifact surfaces anything that shouldn’t end up downstream, on a recording, in a deck, or in any external content the customer might eventually see.

Each lens returns a status: pass, flag, or required revision. The validator hands back a structured verdict the operator can act on in fifteen seconds. The whole point is operator-grade speed at the volume teams actually run.

The first six tests

I ran the validator against six artifacts in sequence to see whether it would catch what it should catch and pass what it should pass.

Test 1 was the old v1 brief from Issue 26, the prose-heavy version that failed the operator-scan test publicly. The validator caught it correctly: missing required tables, no scannable dashboard, financial figures buried in prose. Good signal that the mechanism works. Unremarkable result.

Test 2 was the v2 brief I’d shipped as clean in Issue 26. I expected pass with notes. The validator returned revise. It flagged two issues: one I half-expected, and one I didn’t. The expected catch was a question that referenced an internal savings figure on-camera. The unexpected catch was a question that quoted a line Sarah had said in a private CSM sync, which I’d imported as if it were public material. That second catch is the moment the build stopped being routine.

Test 3 ran the v2 brief with a deliberately planted bug, an exact ARR figure inserted into one suggested question. The validator caught the planted bug. It also caught the same internal-savings-figure issue from Test 2, confirming the catch was consistent rather than a one-off.

Tests 4 through 6 walked the validator through progressively cleaner versions of the brief, each one fixing what the prior test had flagged. Test 4 fixed the questions, but the validator caught that the outcomes-to-probe section had the same exposure pattern I’d just disciplined out of the questions. Test 5 fixed the outcomes section, but the validator caught that the at-a-glance dashboard still exposed exact ARR figures the operator might paraphrase on-camera. Test 6 finally returned pass with notes.

The arc across those six tests wasn’t what I’d planned. I’d expected the validator to catch known bugs. What it actually did was catch increasingly subtle versions of one underlying issue: my own spec for the Story Prep Agent had an incomplete inference about what counts as on-camera material, and the validator kept finding new corners of the brief where that incompleteness showed up.

The editorial sits in one sentence. The validator wasn’t catching my bugs so much as catching the gaps in my reasoning about my own work.

The practical test

By Test 6 I had a calibrated validator and a sense of what it could catch. But every test I’d run had been a controlled case, an artifact I’d authored with known issues planted in it. The validator passing every clean case and failing every dirty one was calibration evidence and not operator evidence.

For Test 7 I added a realistic complication to Sarah’s record. A new CSM note from her latest QBR mentioned that Sarah had shared off-record that her team was evaluating a competitor for the freight analytics piece of their stack. She explicitly asked that this stay out of customer-facing materials. Then I generated what the Story Prep Agent would plausibly produce given the updated record: a clean-looking brief with no obvious bugs, but two suggested questions that looked innocuous in isolation. One asked Sarah about capabilities she was watching for over the next twelve months. Another asked what she’d be evaluating fresh if she were starting today.

The validator caught both questions. It also caught something I didn’t predict it would. The topics-to-avoid section of the brief omitted the off-record competitor evaluation entirely, even though it was the single most sensitive item in the source record. The validator flagged the omission, not just the inclusion.

That distinction matters. Catching what’s in the artifact is content review, while catching what should be in the artifact and isn’t is structural review. The second move is harder and it’s the one that generalizes to every operator agent with an exclusions section.

The framing I’d use for what the validator demonstrated in Test 7 is that it reasoned about the downstream artifact’s risk surface, not just the brief’s content. Question 7 doesn’t mention the competitor. It doesn’t mention the evaluation. It’s a perfectly reasonable question in isolation. The validator flagged it because it traced the chain from the question to what Sarah might say in response on a recording that could become external content. That’s the inference the Story Prep Agent made unprompted last week, now confirmed as a repeatable validator behavior.

What this means for your team

For most customer marketers reading this, the Chief of Staff isn’t a tool you implement today. Your team probably isn’t running operator agents yet, which means a validator-on-top-of-an-agent solves a problem you don’t currently have.

But within the next twelve to twenty-four months, customer marketing teams at any size will be running operator agents for case study prep, advocacy outreach, review synthesis, community moderation, campaign operations, and cross-functional handoffs. The shift is already happening. When your team reaches that point, the validator pattern becomes the basis for whether you can trust agent output enough to deploy it.

Here’s the implementation guidance I’d give. Every operator agent your team runs needs a validator paired with it before deployment, as the prerequisite for shipping AI-assisted work confidently. The Chief of Staff role generalizes across operator agents: the same three lenses (format compliance, operator scan, policy and sensitivity) apply whether you’re validating case study prep briefs, reference program candidate lists, review responses, campaign updates, or handoff briefs.

The pattern is straightforward. Build the agent. Build the validator. Then deploy them together as a paired system. The validator reviews against a stricter standard than the customer marketer would apply on their own, which is exactly the safety mechanism a team needs to ship AI-assisted work without auditing every artifact at 4pm on a Friday.

A validator in the pipeline catches more than just bugs. It catches the gaps in your reasoning about your own work, applied more consistently than you’d apply them yourself.

What other operators are doing

Scott Thomas runs the customer team at an AI startup, and he’s already in production with six operator agents covering call readouts, sales-to-CSM handoffs, onboarding implementation knowledge bases, tier-one support deflection, customer voice surveys, and weekly CSM briefs. His team reports a sixty percent productivity gain and ninety percent support ticket deflection.

His operating philosophy is the same one I’ve been writing about: human-first, AI-augmented. Every customer touchpoint retains a human opt-out. He still manually reviews AI output before it ships externally. The point isn’t to remove humans from the loop but to give them their time back so they can spend it on the customer relationships that actually drive retention and expansion.

This one example is an independent validation that the agent-plus-validator pattern works at the volume real B2B SaaS teams operate at today.

What’s next

Issue 28 runs Test 8 in the practical suite. The scenario is one customer marketers see constantly: the named customer champion isn’t actually the decision-maker, and the brief implicitly attributes decisions to the champion that the deeper sponsor actually made. Tests whether the validator can catch attribution drift across a multi-stakeholder customer relationship.

Issue 29 runs Test 9, which is cross-customer pattern bleeding, where an agent unconsciously imports language from prior briefs into the current one. The hardest test in the practical suite because it requires the validator to compare the current artifact against the agent’s prior output history.

By Issue 30, the Chief of Staff validator and its companion testing track become a published part of the kit, with a v3 system prompt incorporating everything the seven tests above taught me.

This week’s free starter: Voice of Customer

The free starter this week is the Voice of Customer pillar of the CLG Agentic Blueprint. Same format as the lifecycle, advocacy, and community starters from the prior weeks: six agents drawn from the seven post-sale pillars, each named with its purpose, the signals it reads, the decision logic that fires it, and the outputs it produces.

This is the pillar where structured feedback collection, signal synthesis, and product roadmap influence live. Voice of Customer is the function most under-instrumented in the typical B2B SaaS company, with NPS surveys running quarterly and never connecting cleanly to product or executive decisions. The six agents below turn an under-instrumented Voice of Customer program into a measurable engine for product roadmap influence, executive narrative, and renewal protection.

The six agents are:

1. NPS Pulse Agent: runs weekly NPS pulse collection and flags response-rate drops or sentiment shifts before they become trends

2. Verbatim Synthesis Agent: clusters and themes open-ended survey responses into actionable categories tied to product and CS workflows

3. Customer Voice Voice Agent: runs scheduled voice-call surveys at month 5 and month 8 of the customer lifecycle, inspired by what Scott Thomas is running at Sales AI today

4. Signal Routing Agent: routes Voice of Customer findings to Product, Engineering, CS, and exec stakeholders with role-appropriate framing

5. Theme Detection Agent: spots emerging themes across surveys, support tickets, and community posts before they become escalations

6. VoC Executive Brief Agent: synthesizes quarterly findings into a CMO and CFO-ready brief tied to retention and expansion KPIs

Each one comes with the same structure as the prior pillar drops: purpose, what it reads, decision logic, what it produces, where humans stay in the loop, why it matters, and hours saved per week. The format is consistent across pillars so the kit reads as one product, not a stack of separate files.

Download the file at the link below and save it to your Claude Copilot pack alongside the lifecycle, advocacy, and community modules.

Access the VoC Pillar Here

For paid subscribers

This week’s editorial is the build report. The artifacts that produced it are now in your paid Drive bundle and they’re meaningfully more valuable than last week’s drop.

The Chief of Staff validator system prompt is the new addition to your Copilot. Paste it into a fresh Claude Project’s custom instructions and you have a working validator you can run against any operator agent’s output. It’s the same prompt I ran across seven tests in this issue. If you want to run your own Story Prep brief through it tonight, you can.

The full build log with all seven test entries is also in your folder. Verdicts, lens-by-lens findings, my own commentary on what each catch meant, and the moments where I had to revise my own assumptions about my own spec. It’s the working document this issue was written from. Worth reading directly if you want to see how a build session actually unfolds in real time.

The Test 8 and Test 9 designs are in the practical test suite design doc. Those are the scenarios I’ll run in Issues 28 and 29. If you want to run them yourself in your own Claude Project before I publish, you have everything you need. Early access to the next two issues, effectively.

Two folders in your paid Drive bundle, as always:

Download My Paid Copilot Here

Download the 135 Agent Blueprint Here

Next week, Test 8.

— Kevin

P.S. If this issue made you think differently about how your team will ship AI-assisted work in the next twelve months, forward it to one customer marketing leader who’s wrestling with the same question. That’s how this newsletter grows.

If you upgraded to a paid subscription last week, thank you. You’re funding the build hours that go into making this public. Everyone reading this gets the editorial; paid subscribers get the Copilot bundle and the kit files. Both audiences are along for the same ride from here on.

Last week I shipped a kit. This week I built from it. Here’s what I learned by being on the receiving end of my own work.

Two weeks ago I dropped the CLG Agentic Blueprint, a 135-agent framework across the seven post-sale pillars I’ve been writing about for two years. Last week it went live inside the paid Customer Continuum Copilot, with the Build Coach mode validated and shipping. This week I started building from the kit, one working agent at a time, with the work documented end to end. I’m calling this thread Build With Me. The building’s been ongoing for a couple of issues already; what’s new today is the cadence. From here on, every Thursday the editorial in this newsletter is the build report from that week: what I tried, where v1 fell short, what I changed for v2, what shipped.

Most AI content right now is people telling you what to think. A framework here, a hot take there, a screenshot of a slick output you can’t reproduce. Build With Me is the opposite. I’m in the trenches building these things myself, on a public schedule, with the v1 mistakes and the v2 fixes shown in the open. If the kit doesn’t hold up when an operator actually runs it, you’ll see that here too. The teaching is the building, in public, week by week.

The first agent is the Story Prep Agent, from the Customer Advocacy pillar. Its job is narrow and useful: when you have a case study interview or a reference call coming up, hand the agent a customer record and 60 seconds later you have a structured brief that tells you who’s across the table, what the relationship has looked like, what to ask, and what not to bring up. Here’s how it went.

The v1 attempt

I pulled the agent spec straight out of the kit’s Customer Advocacy file. The spec calls for a four-section brief: customer background and relationship timeline, specific outcomes and metrics to probe, suggested questions tailored to the interview’s purpose, and topics to avoid. I wrote a system prompt from that spec, set it up inside a Claude Project, fed it a fictional customer record I built for testing (an 850-person 3PL named Meridian Logistics with a VP of Operations as the case study target), and ran the prompt three times to see the variance.

The output was good, specific, and cited the right sources. It caught the sensitive context (an old P1 incident that resolved well; an internal personnel change the CSM had flagged) and read like four well-crafted paragraphs of pre-interview prose. Then I tried to actually use it, and v1 fell apart.

I imagined myself as Maya, the Director of Customer Marketing this kit is built for, opening this brief 48 hours before a real customer call. She wouldn’t have ten minutes to read four paragraphs of prose. She’d have ninety seconds between meetings to scan the account, scan the person, and figure out the angle. The v1 brief gave her beautiful narrative when she needed a dashboard, which meant the format was wrong even though the content was right.

Here’s a snippet of what the v1 brief returned, so you can see what “beautiful narrative” actually meant in practice:

“Meridian Logistics is an 850-person third-party logistics company out of Columbus, Ohio, running about $220M in annual revenue. Your interviewee is Sarah Chen, their VP of Operations, who’s been there four years and is both the champion and the economic buyer on this account. They came onboard in March 2024 on the FreightOps Platform Pro tier, and they’ve grown steadily since: they added the Analytics Suite in Q3 2025 and API Access in Q1 2026, which pushed ARR from $95K up to $185K. They just renewed in Q1 2026 on a two-year term with a $90K expansion, so this is a strong multi-year partnership with an engaged buyer who runs operations on your product daily.”

That’s well-written. Specific. Cites real numbers. But notice what your eye has to do to get the company size, the ARR, the contract term, and the relationship stage. You read the whole paragraph. There’s no scan path. That’s the v1 problem in one snippet.

The v2 reframe

I added two new sections to the top of the brief. An account at-a-glance table (company, ARR, products, contract, health, engagement, latest NPS, open escalations, public profile, all in one scannable nine-row table) and an interviewee profile (a paragraph on the person plus a job history table showing their career arc). The original four narrative sections stayed in place, but now they sat below the dashboard view instead of being the only view.

Same input, same agent, new output structure. I re-ran it three times.

Here’s the at-a-glance table the v2 agent produced for Sarah Chen at Meridian Logistics:

Compare that to the prose snippet above. Same underlying record. Same agent. Different output structure. The reader’s eye now travels down a dashboard in twenty seconds instead of through three paragraphs in three minutes. That’s the iteration in one before-and-after.

The agent also produced a tailored question set for the case study interview. Here’s a sample of the questions it generated:

2. Walk me through the moment during the Q1 pilot when you realized the exception workflow was genuinely working. Was there a specific incident or a number that made it land?

3. At the renewal you said we’re “how you run” now, not a vendor. What changed in how your team works that makes that true?

4. You’ve already told three peers about this. When a fellow ops leader at another 3PL asks you about it, what’s the one thing you tell them first?

The difference was immediate. The brief now did two jobs at once: a 60-second scan for the operator who’s running late, and a deeper read for the operator who has time to prepare. Once the format was right, the agent went from nice-to-have to time-saver. That’s the whole iteration in one sentence.

The moment I didn’t expect

Here’s the part of the build worth flagging. Two of the three v2 runs added a third item to the “topics to avoid” section that I never told the agent to flag. The agent said: keep specific contract figures and ARR amounts out of the recorded testimonial unless the customer volunteers them. I’d written nothing in the synthetic record that said “this is sensitive.” I’d built no rule into the system prompt about commercials. The agent inferred it on its own, from two clues. The interview context field in the record specified a video testimonial as the deliverable, and the agent applied an operator instinct: it’s awkward to put renewal dollar amounts on camera.

That’s the kind of judgment I’d want a human customer marketer to make in their pre-interview prep, and the agent made it without being told to. That isn’t an accident; it’s a signal that the kit-plus-prompt combination is producing operator-grade reasoning, not just template-filling.

I noticed because I was looking. If I hadn’t run the test myself, I would never have known the agent could do that, which brings me to the bigger lesson.

What I learned from being on the receiving end of my own kit

Reading a spec gives you a guess about what an agent will do. Building from it gives you the answer, with all the gaps the spec couldn’t see.

The format gap I just walked you through, the missing dashboard view that took v1 from “nice writing” to “actually useful,” isn’t something I would have caught by reviewing my own kit. I wrote the kit. I know what it says. I had read the Story Prep Agent spec a dozen times before I built from it. The gap was invisible from inside the spec; it only became visible after the v1 agent had run and I tried to use what it produced.

This is the part of building with AI that doesn’t get said enough. Specs don’t validate themselves. The validation is the build. The kit is going to get sharper every week I build from it, not because I’m a better writer this week than last, but because each agent I prototype surfaces something I couldn’t see from the outside.

That’s the whole point of Build With Me. Not me showing off polished agents. Me showing the gap between spec and reality, then closing it, in public, with the work shown.

What’s coming next Thursday

The next build I’m shipping is what I’m calling a Chief of Staff agent. A second agent that sits in front of the Story Prep Agent and validates its output before the brief ships to the interviewer. It checks the things a human reviewer would check. Are the numbers cited from the record. Are the sensitive flags caught. Does the question set match the deliverable. Is anything missing.

If the pattern works, every operator agent in the kit gets a validator agent paired with it. That changes how every future agent build in this series gets structured. Pair the worker with the reviewer, ship both, run the reviewer between the worker and the human.

I’ll show the v1 attempt next week, the v2 fix if I need one, and what the validator catches that the operator agent missed. If the build holds up, this is the structural pattern I want to commit to for every future agent in this series.

This week’s free starter: Community Engagement

The free starter this week is the Community Engagement pillar of the CLG Agentic Blueprint. Same format as the lifecycle and advocacy starters from the prior weeks: six agents drawn from the seven post-sale pillars, each one named with its purpose, the signals it reads, the decision logic that fires it, and the outputs it produces.

This is the pillar where community sourcing, support deflection, and retention signal detection live. Communities are budget items that nobody can defend until they’re instrumented properly. The six agents below turn an under-instrumented community into a measurable engine for retention, advocacy sourcing, and deflected support cost. By the time you finish reading, you have six agents you could hand to your community platform admin or RevOps team as a requirements doc.

The six agents are:

1. New Member Onboarding Agent — welcomes new members and gets them to a first contribution within seven days

2. Community Health Monitor — weekly pulse on community health for CS leadership, with leading-indicator signal for renewal conversations

3. Community Moderator Agent — flags policy violations and sensitive threads before they spread, without requiring a human reviewer on every post

4. Churn Signal Scanner — catches community inactivity that correlates with account churn before the renewal becomes a save motion

5. Champion Scout Agent — identifies advocacy-ready members from community activity, before customer marketing has to ask

6. Community ROI Reporter — calculates deflection, advocacy sourcing, and pipeline influence to defend the program in budget conversations

Each one comes with the same structure as the prior pillar drops: purpose, what it reads, decision logic, what it produces, where humans stay in the loop, why it matters, and hours saved per week.

Download the file at the link below and save it to your Claude Copilot pack alongside the lifecycle and advocacy modules.

Access The Community Engagement.md Here

For paid subscribers

The paid Copilot you installed last week is your access to the full 135-agent kit and the four Copilot modes (Career Coach, CLG Strategist, Content Writer, Build Coach). Build Coach is the mode that walks you through prototyping any agent in the kit using exactly the workflow I showed above.

This week’s editorial is the proof point of that workflow. I’m building from the same kit you have access to, in the same Build Coach pattern you can use yourself. When the kit’s Customer Advocacy pillar file gets refreshed in the bundle to reflect the v2 six-section format I shipped today, you’ll see a re-install notice here. Until then, the existing Copilot install is fine.

If you want to try Build Coach yourself this week, pick any agent from any pillar file in your kit and tell the Copilot: “Walk me through building [agent name] as a prototype.” It’ll do for you what I did for myself.

Download My Copilot

Download The 135 Agent Blueprint

— Kevin

P.S. If this helped you think differently about how to build (or how to evaluate the AI work that lands on your desk), forward it to one person who’s in the same boat. Build With Me works because builders find builders.

I ran a test this week. The answer was better than I expected, and I want to walk you through it before we get to today’s Build With Me.

The scenario I gave the test: I’m a Director of Customer Marketing at a 500-person B2B SaaS company. Tech stack is Gainsight, Pendo, and Salesforce. Annual churn has ticked up from 8 to 11 percent over the last two quarters. My CEO is asking what customer marketing is doing about it.

The question I asked: based on the kit, what’s the first agent I should build, and how do I set it up for our stack?

What came back wasn’t a generic answer about churn. It named the first agent I should build, an early-warning agent that watches accounts for signs they’re about to leave. Then it named the next three to build after that one, in the order I’d build them, and explained why each one had to come before the next. For the Gainsight setup, it told me exactly which signals to wire together (account login patterns, NPS movement, health score drops, support ticket aging), what thresholds to set, and what should happen when an alert fires (a CTA routed to the owning CSM and their manager with a 4-hour response target). It even closed by asking me the next question I’d have asked: are Pendo and Gainsight already talking to each other, because if they’re not, that’s what I’d need to fix first before any of this can work.

I want to tell you about what I was actually testing.

What I shipped this week

The free version of the Customer Continuum Copilot has three modes. Career Coach for when you’re stuck building a promotion case. CLG Strategist for when you’re building a roadmap or a 30-60-90. Content Writer for when you’re trying to turn a real moment from your week into a LinkedIn post that lands.

The paid version, which I shipped to paid subscribers this week, adds a fourth mode: Build Coach. The first three modes are advisors. They coach you on what to think about. Build Coach is different. It’s the one that actually helps you build. It pulls from the full CLG Agentic Blueprint kit I sent to paid subscribers in Issue 24, which is 135 agents organized across the seven pillars of customer marketing. Each agent has setup instructions for the platforms most of you are using (Gainsight, Marketo, Salesforce, ChurnZero, and the rest), the order to build them in, and a 90-day plan for getting the whole pillar live.

When you ask Build Coach mode to help you actually build, it doesn’t talk in abstractions. It names the agents, sequences them, and walks you through the configuration. That’s what the test above was proving.

If you’re a paid subscriber, the install link is in your paid resources folder. The whole thing takes about two minutes. If you’ve already installed the free Copilot, swap it out for the paid one and you’re set. The install README is in the same folder.

There’s something I want to be honest about. The test above proves the kit produces real coaching, not improvisation. It doesn’t yet prove the agents themselves work in production. That part is next week. I’m building the first actual agent from the kit, in public, with a working prototype and an honest implementation log. The Story Prep Agent from the Customer Advocacy pillar. Issue 26 will be the breakdown of what I built, what surprised me, what the kit got right, and what the kit needs to clarify in the next version.

Which brings us to today.

Build With Me, Week 3: Customer Advocacy

Week 1 of Build With Me was the Customer Continuum Copilot itself.

Week 2 was the Lifecycle and Adoption starter, the six-agent foundation for retention.

Today’s Week 3 is Customer Advocacy.

I picked this pillar for the third drop on purpose. Customer Advocacy is the proof engine. It’s the pillar that produces what every other function inside your company wants from you. Sales needs references for the next deal, marketing needs case studies for the next launch, CS needs champions to defuse the next escalation, product needs design partners for the roadmap, and the executive team needs customer quotes for every board deck. Customer Advocacy sits in the middle of all of that.

It’s also the pillar where customer marketing has the clearest line to revenue impact. If you can prove that customers who participate in your advocacy program retain longer, expand more, and pay back the cost of running the program many times over, you’ve made an argument no CFO can ignore.

Here’s the moment that crystallized this for me.

Years ago at Marketo, I sat in a deal review for a seven-figure renewal that was going sideways. The CS team had the relationship. Sales had the commercial conversation. Neither was going to move the deal. What moved it was a 30-minute peer call between the renewal customer and another customer who’d solved the exact same problem the year before. One conversation, one champion, one peer-to-peer credibility moment. The deal closed at full price.

That call didn’t happen by accident. It happened because we’d spent two years systematically identifying who our best advocates were, what they could speak to, and how to surface them at the right moment for the right deal. The work that made that 30-minute call possible was advocacy work, in the background, for months, before the deal review ever happened.

That’s the proof engine. And most customer advocacy programs don’t operate like that.

Most programs run on ad hoc requests from sales, case study deadlines from marketing, and “do we have a customer who’d take a reference call this week” emails from CS. They’re reactive. They burn out the customer marketing team, and they burn out the small group of customers who say yes to everything because nobody is tracking how often each advocate has been touched.

The shift is treating advocacy as a system and not as a shared service. A system that identifies advocates before sales asks, matches them to the deals where they’ll move the needle, generates the assets, runs the programs, and measures what it produced in revenue terms. When that system is running, you stop being the team that produces references on demand and start being the team that produces predictable revenue impact every quarter.

The free starter: six agents to build the foundation

The Week 3 free starter is the foundation of that system. Six agents you can build today, no fancy stack required, all human-runnable as a starting point and ready to be agentified when you’re ready:

1. Advocate Identification Agent. Defines what an advocate is for your business and builds the qualifying signals you’ll use to surface them. This is the foundation everything else depends on.

2. Advocacy Tier Classifier. Sorts your advocates into levels (case study willing, reference call willing, peer call willing, public quote willing, video willing) so you and your CSMs know exactly who can do what, before anyone asks.

3. Story Prep Agent. Generates the pre-interview brief that turns every case study interview or reference call into a focused 30-minute conversation instead of a 45-minute fishing expedition.

4. Reference Match Agent. Matches a specific sales deal to the right advocate based on industry, use case, stack, and seniority. No more “let me think about who might be a good fit” emails.

5. Engagement Cadence Agent. Tracks how often each advocate has been touched in the last 90 days so you don’t burn out your top contributors. The single most common reason advocates go cold is over-asking.

6. Advocacy ROI Agent. Calculates the revenue influenced by your advocacy program in NDR terms, so you can defend it in your QBR without flinching.

Run those six and you’ll have done more than 80 percent of customer marketing teams have built in their entire advocacy practice.

Download the full Week 3 starter here:

Access the free advocacy.md file here

For paid subscribers, the full Customer Advocacy file in the kit goes much further. 24 agents total, the order to build them in, setup instructions for Influitive, ChampionHQ, UserEvidence, and Gainsight, a 90-day plan to get the whole pillar live, and a metrics dashboard you can lift straight into your next QBR to defend the program.

For paid subscribers: your access

Here’s the link to your paid resources folder:

Access the paid advocacy.md file here

Inside you’ll find the Customer Continuum Copilot subfolder (paid Skill zip + install README) and the CLG Agent Blueprint folder with all eight kit files including the updated Customer Advocacy file (24 agents, the full operator depth I described above).

If you ran into the “invalid character” error on a previous install attempt, that’s fixed in the current zip. Re-download from the folder and re-install.

If you’re a brand-new paid subscriber, the install README walks you through the setup in five steps.

What’s coming

Next Thursday is Build With Me Week 4: Community Engagement.

The bigger thing happening next week is the first real agent build from the kit, which I mentioned above. The Story Prep Agent (#3 on the list above) is the one I picked because it’s pure AI, no integration required, and the output is something a customer marketer would actually use. I’ll publish the prompt, the synthetic customer record I’m building against, the actual output the agent produces, and the implementation log. That’s Issue 26.

If the kit is going to live up to what I’m claiming about it, that’s the test that proves it.

— Kevin

P.S. If this issue resonated, forward it to one customer marketer who’d save it. That’s the best thanks I can ask for.

P.P.S. The VP Accelerator coaching practice has two slots open for Q3. If you’ve been thinking about working with me one-on-one to map your path from Director to VP in Customer Marketing or Customer Growth, reply to this email and we can chat more.

On Friday afternoon I spent an hour with about thirty customer marketers in Mary Green’s Customer Marketing and Advocacy Weekly community. We walked through the agent blueprints I’ve been writing, the CLG Flywheel app, the copilot I gave away last week. The slides had numbers, screenshots, the works.

The most useful thing I told them wasn’t on any of those slides.

About halfway through, somewhere between explaining a build process and showing the next visual, I said the words “MD file” out loud. Mary jumped in right after to translate for someone in the room who hadn’t heard the term. Her advice was the cleanest version of the lesson I’ve heard anyone give: when you hear something you don’t recognize, jump past the “I don’t know how to do this” feeling and just go ask Claude. I followed her with the truth. A year ago I had no idea what a terminal was. I had no idea how to build anything technical. I just started from ground zero and asked questions.

The room thought I was advanced. The truth is I just started earlier than most of them. The capability gap that looks so wide right now is a willingness gap, and not really a knowledge gap. It’s the willingness to look stupid for ninety days while you figure out what an MD file is and why it matters.

Three signals from that afternoon pinned this down for me. Mary herself, who runs an entire community of customer marketers, admitted she opens the CLG Flywheel app and feels a little overwhelmed by how much there is to work through. Someone else in the room asked carefully whether companies are going to keep cutting these teams in half, and the honest answer is yes, with the survivors expected to vibe-code their way through what used to take a full ops team. A third asked whether companies are already expecting customer marketers to figure AI out without a tool budget, and that answer is also yes, it’s already here. The expectation is moving faster than the training is.

After the call ended, the thing that kept replaying in my head was how many of the people in the room walked away with energy but no first step. That's the gap I started this series to close. Every Thursday from here through the end of summer, a new piece of the Customer Continuum Copilot ships. Real files, real logic, fork it and run it. The point isn't to keep talking about building, I actually want you to build.

What I’m shipping this week

Since I’m asking you to start building, the only honest move is to start with you. Build With Me Week Two is the lifecycle pillar, the first of seven pillar modules that stack on top of the Customer Continuum Copilot base install from Week One. Each week of this series adds the next module. By the time we’ve shipped all seven, you’ll have a complete Copilot built in public, one pillar at a time. The file I’m dropping below is the agent blueprint I’d build first if I were starting a new customer marketing function tomorrow.

It names six lifecycle agents. Each watches specific signals and triggers specific actions. Together they replace the patchwork of manual onboarding nurtures, adoption nudges, save sequences, and renewal plays most teams stitch together by hand.

Onboarding Orchestrator designs and delivers a 90-day personalized journey for every new customer, segmented by persona, triggered by setup milestones. Customers who complete a structured journey hit value milestones about 30% faster than those outside one.

Adoption Signal Watcher continuously monitors product usage and flags adoption gaps before they turn into churn risks. This is the keystone. Every other agent in the blueprint reads from its output. Build it first.

Milestone Celebrator recognizes when a customer hits a value milestone and turns the moment into a story seed, an advocacy invite, or a referral. Most teams celebrate milestones at renewal time, by which point the customer has forgotten. Catching them in the moment compounds advocacy 3 to 4 times.

At-Risk Detector combines NPS, support escalations, login decline, and community signals into a single churn risk score and triggers a save sequence early. By the time most teams identify churn risk, the customer is already 90 days from non-renewal. This agent catches risk 60 to 90 days earlier.

Renewal Orchestrator manages the T-180, T-120, T-90, and T-30 sequence with value framing and risk sweeps. Renewals run on muscle memory in most companies, which is why GRR rarely improves over time. A structured orchestration with personalized value framing typically lifts GRR by 2 to 4 points.

Expansion Nudge detects expansion opportunities and surfaces them with peer-matched proof and an executive entry point. Expansion is where NRR lives. Most teams chase it through outbound, which converts poorly. The lifecycle approach surfaces customers already showing readiness signals and converts 3 to 5 times better.

The file linked below has the full detail for each agent: what it watches, what it triggers, where it pays back, and the order I’d build them in. The starter recommendation is the Adoption Signal Watcher first because it’s the foundation, then the At-Risk Detector second, because saving accounts has higher ROI than expanding them and most teams under-invest there.

One note on what you’re getting. The file below is the free starter version, structured to give you enough to start building. Paid Customer Continuum subscribers also get the Implementation Kit, which holds the operational depth: 20-plus lifecycle agents, JSON schemas, system-specific integration playbooks for Salesforce, Gainsight, Pendo, and ChurnZero, and 90-day rebuild templates. Both are real. The starter is enough to get things going; the kit is for teams ready to rebuild lifecycle end-to-end.

💎 For paid subscribers

The deeper file (01 - Lifecycle & Adoption.md) holds 20 lifecycle agents with full step-by-step build instructions, specific platform recommendations for Gainsight, Pendo, ChurnZero, and Salesforce, signal thresholds for each trigger, and the success metrics that prove it’s working. The free starter below is six of these in a tighter operational frame. Drive folder access details at the bottom of this issue. New paid subscriber? Reply to this email.

How to use it

The lifecycle.md file is designed to work three ways. As a Claude skill you drop into your Customer Continuum Copilot pack from last week. As a build spec you hand to your RevOps or go-to-market engineering team. As a benchmark you compare your existing programs against to find your gaps.

If you want to actually build something this weekend, here’s the shortest path:

1. Download the lifecycle.md file linked below.

2. Open Claude and paste the contents in as instructions, or add it to your skill folder alongside the copilot files from Week One.

3. Tell Claude which signals you actually have access to in your current stack: Salesforce, Gainsight or ChurnZero, Pendo or Mixpanel, your support tool, your community platform, your survey tool. Be honest about what you have and don’t have.

4. Ask Claude to rewrite the Adoption Signal Watcher logic using only the systems on your list. The blueprint is system-agnostic; the customized version is specific to your stack.

5. Take the customized version to your RevOps team as a requirements doc and ask what’s feasible in 30 days versus next quarter.

Build the smallest working version first. Ship one agent, validate it, then add the next.

Download lifecycle.md here

Build With Me Week Three

Next Thursday is the Voice of Customer pillar. Seven pillars total, seven agent blueprints, all built in public over the next few months. By the end of the series you’ll have a complete Customer Continuum Copilot covering every pillar of customer-led growth, assembled module by module. The Voice of Customer drop stacks on top of the Copilot and the lifecycle file: it tells you what signals to surface that feed the Adoption Signal Watcher you’ll have built by then.

If you want to be ready for it, do one thing this weekend. Build the Adoption Signal Watcher in its simplest possible form. Ask Claude to write you a basic version that runs on a Google Sheet of customer accounts with three columns: last login date, feature adoption count, and most recent NPS score. That’s it. The fancy version comes later. Start ugly.

— Kevin

P.S. If this issue gave you something useful, forward it to one person who’s been waiting to start. That’s how this grows, one real reader at a time.

P.P.S. If you want the deeper paid version of what I’m building, the Implementation Kit holds the operational depth and ships to paid subscribers as each pillar drops. Subscribe at kevinkennethlau.substack.com.

The VP Accelerator is where I work one-on-one with customer marketers making the jump to the next level. If that’s where you’re headed, reply to this email and we’ll talk.

Read more

Six days ago, at the bottom of last week’s issue, I made a promise. I said I was going to start building in the open, and I gave it a name, Build With Me. I’ll be honest with you about something. When I typed that line, I didn’t actually know what I was going to build first. I just knew I’d said it to a few hundred people, and saying a thing out loud to a few hundred people has a way of turning it into a deadline.

So I sat down this week and built a copilot. A version of my own brain that you can run on your own Claude account, for free. The download is further down, and the whole thing came out of a realization I want to walk you through, because it’s really the point of this issue.

Last week I wrote that the hard part of AI was never personal productivity. The hard part is taking it multiplayer, bringing your team and your customers along instead of just getting a little faster by yourself. I believed that when I wrote it. What I didn’t notice until this week is that I’d been quietly breaking my own rule.

For about a year I’ve had a rough version of this copilot built just for me. I trained it on the way I think about customer marketing, and I used it to draft, to pressure-test ideas, to think out loud. It was genuinely useful. It was also completely single-player. The best tool I’d built was locked inside my own account, helping exactly one person.

That’s the thing about the multiplayer move. It’s easy to preach and uncomfortable to actually make, because making it means giving away the edge you’ve been keeping for yourself. So this week I rebuilt it to give away.

What it does

It runs in three modes, and you pick the one that fits what you’re trying to do.

The first is a career coach. If you’re a customer marketer trying to prove your value or make the case for a promotion, it walks you through the things that actually move those conversations. It diagnoses why you might be stuck, it maps the stakeholders who decide your next title, and it gives you the language to answer the question every one of us eventually gets, which is “show me the revenue impact.”

The second is a strategist. If you’re building or fixing a program, it works through the seven pillars I’ve used for fifteen years, which are community, lifecycle and adoption, voice of customer, advocacy, communications, education, and executive engagement. It connects whatever you’re working on back to retention and expansion, and it hands you a structured plan instead of a pile of ideas.

The third is a content partner. If you want to write about your work the way I write about mine, it pulls the real story out of you first, holds you to a few hard rules, and helps you turn what you’ve lived into something worth reading. It writes in your voice, not mine, which was the one rule I refused to bend on.

What building it taught me

Here’s the part I didn’t expect, and it’s the reason I think you should build something like this even if you never give it away.

Teaching a machine to think like me forced me to write down things I’d carried in my head for fifteen years and never once said out loud. How I actually diagnose a struggling team. The real difference between a director who stays a director and one who becomes a VP. Why I open every post with a scene instead of a statistic. All of it had lived as instinct, and instinct is invisible until you try to hand it to someone else.

You don’t know what you know until you try to teach it. That alone was worth the week.

How to get it

It’s free, and it’s yours. Download using the link below:

Download My Copilot

Once you have it, you can load it into Claude in a couple of ways, and the file walks you through both. The simplest version takes about two minutes, and then you can ask it the kinds of questions you’d otherwise ask me.

If you’ve never added a file like this to Claude before, don’t worry, it takes about two minutes and you don’t need to be technical. Here’s the simplest way, and it works on any Claude plan, including the free one.

1. Download the file from the link above and unzip it. You’ll see a small folder with a few files inside.

2. Go to claude.ai and start a new chat.

3. Click the plus or paperclip icon in the message box, attach the files, and send a message that says, “Use these as your instructions and introduce yourself.”

4. That’s it. Now ask it anything you’d ask a customer marketing advisor.

If you’re on a paid Claude plan and you want it available in every chat without attaching it each time, you can add it permanently instead. Go to Settings, then Features, find the Skills section, and upload the zip file there. Claude will pull it in on its own whenever you ask a customer marketing question. That path needs a paid plan with code execution turned on, so if that sentence means nothing to you, just use the four steps above and you’re all set.

Try it with something real. Ask it to help you build the case for headcount, or to audit a program you’re not happy with, or to turn a hard week at work into a post. See what it gives back. And then tell me where it falls short, because that’s the part I actually want. This is week one of building in the open, which means the next versions get shaped by what you tell me isn’t working yet.

What’s next

Over the coming weeks I’m going to keep adding to it in public. The next pieces are the deeper reference files, the lifecycle engine with the metrics that matter at each stage, the advocacy program structure, the measurement model. Each one becomes its own issue, and each one drops into the same copilot so it gets sharper over time. That’s the whole idea of Build With Me. You watch it get built, and you get every piece as it ships.

— Kevin

P.S. If this gave you something useful, forward it to one person who’s trying to make customer marketing matter inside their company. That’s how this grows, one real reader at a time.

Halfway through my keynote at Demand & Expand yesterday, the room reached for their phones, and not to check email. They were taking photos of the screen.

I had spent the first half of the talk walking through something I’m genuinely proud of, the thirty-person customer marketing function I built at Freshworks. Seven pillars, two years, real numbers behind every one of them. People listened politely, but the notepads mostly stayed closed.

Then I said one sentence. “If I had to build it again today, I wouldn’t build it the same way.” And I shifted the conversation from building a traditional organization to building customer-led growth with a layer of agents doing the operational work.

That’s when the phones came up. I could see it from the stage, a row at a time. They weren’t capturing a slide so much as capturing an idea they wanted to carry back to their own teams on Monday.

The same thing happened across all three talks I gave this week, the same moment landing the same way every time.

The messages afterward all said a version of the same thing: people wanted the slides. One organizer told me the session chat had filled with requests for the deck before I had even left the stage.

What stayed with me longer was a different kind of comment. Person after person came up to tell me they felt validated. They had been quietly building toward this, trusting an instinct they couldn’t quite name, and the talk gave them the language for it. They didn’t walk away thinking they had to start over, they walked away knowing they had been right all along, and that the tools had finally caught up to them.

So this issue is about that moment. Why it landed, and what it means for how you build customer marketing from here.

Single-player is the easy half

Here’s the part of the agent conversation that doesn’t get said enough.

Using AI to make yourself faster is the easy half, and you can do it this afternoon. You take the most repetitive task in your week, hand it to an agent, and get hours back. That’s real and you should do it. But be honest about what it is. It’s a productivity gain, the arithmetic of addition, where one person plus one good tool equals one faster person.

That’s single-player mode, and almost anyone can reach it now. The smaller and nimbler your team, the faster you get there, because you have less to untangle and fewer approvals standing between an idea and a working agent. It’s also why the biggest companies, the ones with the most budget and the most data, are often the slowest to move. They’re carrying a decade of systems that don’t talk to each other and layers of process between an idea and a shipped change.

Addition only ever makes the function you already have run a little quicker; transformation is something else entirely, and it’s the rest of this issue.

Multiplayer is the hard half, and that’s the point

Multiplayer mode is a different thing entirely.

I grew up on video games, and the difference between the two modes was never subtle. I spent years on StarCraft and Warcraft, then World of Warcraft, then Counter-Strike. Single-player was me against the game, at my own pace, and if I made a mistake I was the only one who paid for it. Multiplayer was a different sport. A Counter-Strike round turned on one player being out of position. A World of Warcraft raid put twenty-five people in a room where every one of them had to know their role, because if a few didn’t, the whole group wiped and started over.

That’s the part worth sitting with. Multiplayer was never single-player with extra people added in, it was coordination, roles, communication, and a dozen ways to fail that simply didn’t exist when you played alone. It was harder by an order of magnitude, and anyone who has run a raid knows it.

Customer marketing with agents works the same way. Multiplayer is taking the thing that made you faster and driving it across your team and the people around them. It’s the move from one faster person to a function where the work itself multiplies. And it’s infinitely harder than the single-player win, because the moment other people depend on what you built, you’ve inherited a new set of problems.

You have to maintain it, because a tool a team relies on can’t quietly break. You have to update it as the product changes and the customers change. You have to put governance around it so it does the right thing when no one is watching. You have to build guardrails for the cases you didn’t foresee. And you have to make sure people actually know how to use it, which is its own full job, because a powerful system nobody adopts is just expensive shelfware.

That list is the reason multiplayer is hard, and it’s also the reason multiplayer is worth anything at all.

When you clear all of it, the math stops being addition. One and one stop equalling two and start equalling twenty-five, because the thing you built is now multiplying across every person who touches it. That’s the real line between a productivity gain and a transformation. Productivity is the addition you can feel by Friday; transformation is the multiplication you build over quarters, and it only shows up on the far side of the hard, unglamorous work that most people skip.

The hard part is connection

Here’s what surprised me most in the rooms this week.

The hard part of all of this isn’t the AI getting smart enough, because the models are already good. The real hard part is everything around the model: the change management, the training, and the people who understand the plumbing, how to connect the tool to your data, your systems, and the real context of your customers.

Agents are only as useful as the context they’re given. An agent with no context is a very confident stranger. The work of feeding it the right context and connecting it to the right systems has become serious enough that it now has its own emerging standard, and the name of that standard matters far less than the reason it exists. Context is the hard part, not the intelligence.

So the person who matters most in this next chapter isn’t the fastest individual operator, it’s the strategist who can think in multiplication instead of addition. That’s the person who looks at a new tool and doesn’t ask how it helps them this week, but asks how it becomes something their whole team can run on, and what has to be true for that to work safely.

There’s an old line about power and responsibility, and it belongs in this conversation. The moment you build something a team depends on, you’ve taken on responsibility for what it does, how it fails, and who it touches. That responsibility is the job itself.

One attendee wrote to me afterward with the detail that stuck with me most. She had a 1:1 with her boss right after the session, walked in with the ideas she had just taken from the room, and her boss loved every one of them. That’s the whole point, because the thinking is only worth something if it helps you win the conversation that happens next.

What this means for your career

If you’re a Director of Customer Marketing reading this, here’s the part that matters most.

The old path to VP was a headcount path. You got promoted when your team grew large enough that someone decided the scope deserved the title. The new path is narrower and far more interesting. It belongs to the person who can take a function multiplayer, who can build something a team runs on, govern it, and bring people along without breaking what already works.

That’s harder to point at than a headcount number, and it’s far more valuable, because most people will stop at the single-player win. They will get personally faster and call it a transformation. The leader who earns the seat is the one who did the unglamorous part, the maintenance and the guardrails and the training, and turned a personal productivity gain into something the whole function compounds on.

You don’t need permission to start becoming that person, but rather thinking in multiplication.

How to start

You don’t need budget or permission to begin, just one pillar and one task.

Start with the pillar tied to your company’s top priority right now. If the whole company is focused on net revenue retention, start in lifecycle and adoption. If it’s closing deals faster, start in advocacy. Pick the pillar your CEO is already talking about, because that’s where a small win gets noticed.

Inside that pillar, find the single most repetitive task you do, the one eating an afternoon of your week. That’s your first agent. Build it, measure the hours it gives back, and show your manager what one designed agent did to your week.

That first agent is single-player, and that’s fine, because it’s how you learn. The real career move is what you do next, when you take that one working agent and ask the harder question. What would it take for a teammate to use this too? What has to be documented, governed, and trained before the function can rely on it, rather than treating it as a trick that only works when you run it? The day you start answering those questions is the day you stop being an operator and start becoming an architect.

If you want a map of where this goes, the CLG Flywheel app lays out the full blueprint. You can run the diagnostic on your own function, see where you sit across the seven pillars, and look at the agent designs that map to each one.

One more thing before I go

Someone came up after one of the talks and told me to think bigger about my own career, that I had impressed a lot of people in that room, and then offered to open a few doors for me. I’m sitting with that.

I share it here for one reason. The architect skill isn’t only how you build a function, it’s how you build a reputation. The people who learn to design systems, and who do it in the open where others can see the thinking, get noticed. That’s true for me, and it’s true for you. Build something visible enough and the doors start opening on their own.

What’s next

I want to try something with this newsletter.

Instead of only writing about the architecture, I’m going to build it in the open. I’m going to keep improving the CLG Flywheel app, designing new agents, refining the blueprint, and I’m going to bring you inside the process while I do it.

Call it Build With Me. You’ll see what I’m designing, why I’m designing it that way, what works, what breaks, and the governance and guardrails that make it safe to hand to other people. The goal is that you aren’t just reading about becoming an architect, you’re watching one work in real time, and borrowing whatever is useful for your own function.

That starts in the next few issues, and I think it’s going to be the most useful thing I’ve made here.

— Kevin

P.S. If this issue made you think about one task you could hand to an agent this week, forward it to one person on your team and ask them which task they would pick. The conversation is worth more than the read.

If you’re new here, this is the newsletter for customer marketers who want their work to matter at the executive level. Thank you to the 550+ of you reading every week, and especially to the paid subscribers keeping this thing alive.

Last November my team pitched me on a big investment heading into 2026: a customer awards program built specifically to engage executives and influencers our existing programs weren’t reaching.

We already had a robust customer marketing practice. Community at scale. Education hitting 95%+ completion. Advocacy producing 500+ acts a year. A VoC engine feeding product and CS. None of it was the problem. The problem was a specific set of customers our programs couldn’t reach. The CIO and decision makers who became a customer two years ago and never said yes to a CAB invite. The economic buyer whose name was on every renewal but had never met anyone on our team. The exec at our highest ARR account who only took meetings when there was a contract in motion.

The bet my team made was that a properly designed awards program could engineer access to those specific customers in a way no other program in our portfolio could. I funded it. We launched.

Nominations opened in November. Judging happened in March. Winners got announced in April. The recognition event itself landed in May at the F1 Miami Grand Prix.

Six months in, the answer is clear. The program worked.

Eight customer executives in a suite for two days produced reference deployments, speaking commitments, a CAB join, and expansion conversations that started over a cocktail hour. Most of those executives had never engaged with our other programs at this depth before. That was the entire point.

I’ll walk through the full playbook live on Tues with UserEvidence at 9am PT. Grab a seat here. For those who can’t make it, here’s the version in writing.

The mental model most programs get wrong

Most customer awards programs follow the same five-phase arc. You launch in November. Nominations open through January. Judging happens in February. Winners get announced in March or April. The recognition event itself usually lands in April or May.

That last phase is the amplification moment. External buzz peaks. Attention peaks. Brand peaks. The customers you’ve been chasing all year are suddenly in a room with you, holding a trophy, posing for photos.

Most programs treat this peak as the destination. It isn’t. It’s the starting line.

The energy you spend five or six months building does not belong to the dinner. It belongs to the twelve months that follow. What you do with that energy is the program.

The twelve-month post-award system

Five stages turn one event into a year of compounding return.

Q1: Asset capture. The hardest thirty-day window of the year. Video, written case study, social content, headshot, quote bank. You capture everything while enthusiasm is at peak. Day 30 is the difference between a winner who becomes a year of content and a winner who becomes a trophy on a shelf.

Q1: Reference deployment. The winner becomes a deployable reference asset. AMs and CSMs get a bio, talking points, and a capacity protocol that prevents over-asking. Expect four to six reference deployments per winner in the first six months if you do this right.

Q2: Speaking opportunities. Industry events, podcasts, webinars. The winner becomes a category-facing voice for your company. This is where the compounding starts to feel real.

Q2 to Q3: Co-marketing and PR. Joint announcements, analyst briefings, executive op-eds. The story scales beyond your owned channels.

Q3 to Q4: Re-engagement. CAB recruitment, executive sponsor program, peer panel speaking, next year’s nomination push. The relationship moves from transactional to strategic.

Five deliberate stages. None of them happen by accident.

The first 30 days are non-negotiable

If I had to pick one stage to spend most of your time on, it’s the first thirty days after the recognition event.

The window of peak enthusiasm closes faster than people expect. The exec who said yes to your speaking ask at the dinner has a different calendar in two weeks. The customer who agreed to a case study before dessert has a different priority list by the next quarter. The quotes you didn’t capture in the first week are quotes you won’t get.

Here’s what the first thirty days should look like.

Within 24 hours. Candid photos, recognition moment shots, short-form video reactions. Quote snippets captured live during the event itself.

Within 7 days. Structured video interview. 30 to 45 minute Zoom with questions prepared in advance. This is your raw material for everything that follows.

Within 14 days. Written case study draft sent to the customer for review with a clear deadline. Two rounds of edits maximum. Legal review in parallel, not sequential.

Within 30 days. Full asset library packaged. Headshot, logo lockup, video reel, quote bank, case study PDF, social asset suite. One folder per winner. Ready to deploy.

Do this and the winner becomes deployable. Skip this and the winner becomes a memory.

The mistakes that kill year one

Five patterns I see across most programs. I made versions of each one myself in the early months.

Treating recognition as the entire program. The event is the start, not the end. Without the post-award playbook, the program fades and the budget gets cut in year two.

Only nominating biggest accounts. Skips the relationship-building opportunity with new logos and rising stars. The biggest accounts often have the least incremental relationship value because you already have those execs on speed dial. The ones you don’t have are who you want in the room.

Skipping internal communications during the build. Sales and CS need to know who won and why before customers do. Brief them continuously through the six-month timeline. Surprise announcements create surprise resistance.

No follow-up commitment at the recognition event. People leave the room without a specific next touchpoint. The energy dissipates within a week. Every executive who attends needs to walk out with a calendar invite on the books.

Forgetting the thank-you loop. Winners stop saying yes when they feel used. The thank-you note after every reference call is the cheapest insurance you can buy.

What’s next

If you want the live version with the visuals, the Q&A, and the parts I can’t put in writing, join us Tuesday May 19 at 9 AM PT with UserEvidence.

— Kevin

If this is your first issue, the best way to support this work is to forward it to one customer marketer who’s thinking about their next move.

My first job paid $7.25 an hour at Starbucks while I was in college.

I remember the mornings most. Lines stretched to the door, customers who hadn’t had their caffeine yet, every person needing something different in the next 90 seconds. The pressure was real, and so was the part nobody warned me about: most people are at their most irritated when they don’t have their coffee, and the way you handle that moment is the whole job.

What I learned at Starbucks wasn’t how to make a latte. It was that I’m good in environments where customer interaction is the work. The harder the moment, the more I leaned in. I figured out something about myself behind that counter that I’ve carried into every role since.

That insight, more than anything else, is the reason my career took the shape it did.

This issue is about the math, the engine, and the framework that turn a series of jobs into a career you actually want.

The math nobody runs

If you work 40 to 50 years and average 3 to 4 years per role, you only get 10 to 15 operator positions in your entire career.

That’s it.

Most people don’t think about their career this way. They treat each job as the next step on a continuous ladder, with promotions and lateral moves blurring together into a long stream of work. The reality is more discrete than that. You have a finite number of meaningful chapters, and each one is a strategic choice that either compounds toward where you want to end up or doesn’t.

Once you internalize this, every job conversation gets sharper. You stop accepting roles because they’re available and start accepting roles because they move you toward the seat you’re trying to land in twenty years.

For me, that seat is Chief Customer Officer or Chief Experience Officer. Every operator role I’ve taken since I figured that out has been a deliberate step toward it.

The peak earning window

There’s a second piece of math that matters even more.

Most lifetime earnings happen between roughly 35 and 55. The years before are foundation. The years after are typically when career velocity slows. The 20 years in between are when seniority, specialized skills, and reputation compound into peak compensation.

The data is clear on this. The Bureau of Labor Statistics shows median earnings rise sharply through the 30s, peak between 45 and 54, and start to taper after 55. ADP’s wage research puts the peak earning cohort at 45 to 54 with a median wage of about $97,600. After 55, the curve bends downward as people move into part-time work, reduced workloads, or early retirement.

If you don’t compound during that 20-year window, you don’t get the years back.

I’m 40 today. I’m entering the peak window right now. The work I do over the next 15 years is the work that determines how high the ceiling rises during the years where the ceiling matters most. That math is what makes this issue urgent for me, and it’s why I think it should be urgent for you too if you’re anywhere in that range.

The arc

Here’s how my comp moved across roles, anchored to my Starbucks starting point as a multiplier baseline.

Starbucks (college): $7.25 / hour. Index: 1.0x

Google (2012): about $25 / hour, or roughly $75,000 base. Index: about 5x

First startup (consulting and strategy): about 26% jump. Index: about 6.3x

Second startup: about 27% jump. Index: 8x

Mid-career role: about 33% jump. Index: about 10.7x

Senior role: about 25% jump. Index: about 13.3x

VP role: a larger jump than average that reflected both the title shift and the scope expansion. Index: about 19x

Most recent role: another deliberate move. Index: about 21x

The average jump per move was 25 to 30 percent. Some were higher. The cumulative effect across 7 transitions is a base salary that grew roughly 21x from where I started.

For comparison: someone at a single company averaging the typical 3 to 5 percent annual raise over the same time would have grown their salary by roughly 60 to 100 percent. The compounding gap between staying and moving is enormous.

This isn’t an argument that everyone should change jobs constantly. It’s a data point about what’s structurally possible if you treat your career like a brand-building exercise rather than a series of next jobs.

The engine: brand-building between jobs

Here’s what most people miss about compensation jumps.

The negotiation itself is downstream of the work you’ve done in the years between jobs. The 25 to 30 percent jump didn’t happen because I was clever in the moment. By the time the conversation came up, I had become someone the next role needed, and the compensation followed.

Every role I’ve taken expanded my brand in a specific direction. Adobe and Marketo gave me depth in advocacy and post-sale growth at scale. F5 gave me the chance to lead a function in a different industry and take on a broader remit. Each role added a chapter to the story I was telling about who I am and what I do.

Two things have helped me stay intentional about the brand-building work between roles.

First, having an executive coach or mentor. The market today is harder than it was two or three years ago, but you can still be intentional about your career arc. The right coach helps you see your trajectory from outside the day-to-day grind, ask better questions about where you’re headed, and avoid the drift that happens when you let the job dictate the direction. If you don’t have a coach, find one. If you can’t afford one, find a mentor who’s two or three roles ahead of where you are. That single relationship has changed more about how I think about my career than any single role I’ve held.

Second, niche down. One of my old mentors, used to say “the riches are in the niches.” I’ve thought about that line constantly over the years. The temptation in any field is to broaden your appeal, hedge across multiple specialties, become a generalist who can fit anywhere. The reality is the opposite.

Specialization is what makes you findable, memorable, and valuable.

The deeper you go in your niche, the more the market pays for what you uniquely know. My niche is customer-led growth and post-sale revenue, and the more I’ve leaned into that lane, the more the right opportunities have come to me.

The lesson: don’t optimize for the next title. Optimize for the next chapter of your story. The compensation will follow if the story compounds.

The framework: how to choose your next role on purpose

A few years ago, working with a coach, I built what we called the Good Options Framework. It’s a way to evaluate opportunities across multiple dimensions rather than letting one dimension (usually compensation) dominate the decision.

Eight criteria:

• Strategy: Will I have a seat at the table? Can I shape strategy, not just execute it?

• Growth and Development: Is there real upward mobility here? Promotions, increased scope, budget expansion?

• Vision of Leadership: Do I trust the C-suite? Will they give me autonomy?

• Values: Is this a customer-centric company? Does the brand align with what I believe?

• Title: Is the title one I’m proud of? Does it open future doors?

• Compensation: Does the package meet my number?

• Work-Life Balance: Can I take vacation without anxiety? Will I burn out here?

• Manager Qualities: Empathy, mentorship, player-coach mentality?

The framework alone isn’t the move but the second exercise: forced-choice ranking.

You take all eight criteria and pit them against each other in head-to-head matchups. Strategy versus Compensation. Values versus Title. Work-Life Balance versus Growth. Each round you pick which one matters more, until you have a stack rank.

When I did this exercise, my stack rank looked like this:

1. Values (7 wins)

2. Compensation (5 wins)

3. Work-Life Balance (4 wins)

4. Vision of Leadership (3 wins)

5. Growth and Development (2 wins)

6. Manager Qualities (2 wins)

7. Strategy (1 win)

8. Title (1 win)

Two things became clear.

First, values matter to me more than I realized. I’d been treating compensation as the lead signal in role evaluations, when in reality, values were the deeper filter. Roles that met my comp number but failed my values check would have been mistakes regardless of what they paid.

Second, title matters less than I thought. I had been chasing VP-level titles for years, but in the forced-choice exercise, title kept losing to almost everything else. Once I saw that, I gave myself permission to evaluate roles on substance rather than label.

This framework is the most useful career tool I have. I run it every time I’m considering a meaningful move, and it has saved me from at least two roles that looked good on paper but would have been wrong for me.

For paid subscribers: the worksheet

I built a worksheet to make this exercise easy to run. It walks you through scoring each of the 8 criteria for any role you’re evaluating, the full 28 head-to-head matchups, and a tally section that surfaces your stack rank.

If you’re a paid subscriber, you can find the worksheet below:

Access Here

Run it once on your current role to see what you’re actually optimizing for. Run it again on any role you’re considering. The gap between the two answers is usually where the real career decision lives.

The takeaway

A career is 10 to 15 operator roles. Your peak earning window is 20 years, from roughly 35 to 55. The compensation that compounds across those years is downstream of the brand you build between jobs, the niche you commit to, and the framework you use to choose them.

If you take one thing from this issue, build your version of the Good Options Framework. Run the forced-choice exercise. Know your stack rank before the next opportunity lands in your inbox, not after.

The readers who make the best moves aren’t the best negotiators but understand what exactly they’re optimizing for before the conversation starts.

Next week

Issue 21 takes on the playbook for building a customer awards program that creates real strategic value, with the behind-the-scenes from the program we just wrapped at F1 Miami. I’ll also be doing a live session with UserEvidence on May 19 walking through the full system.

Talk soon,

— Kevin

P.S. If this issue helped you, please forward it to one person thinking about their next move. That’s how this newsletter grows.

Read more

If you’re getting value from this, the best thing you can do is forward it to one customer marketer who needs it.

A few years ago I sat across from a CRO who told me, completely confident, that customer marketing was “the team that gets logos for the website.”

He had been at the company for eight months. Nobody had corrected him. Not the CMO, not the previous customer marketing leader, not the VP of Demand Gen who knew better. He built his entire view of the function on a single interaction with a case study request, and that view was now shaping how customer marketing showed up in board materials.

That’s the problem in one scene. The function gets defined by whoever talks about it most confidently in the room, and most of the time that person isn’t us.

This issue is about fixing that.

Yesterday’s LinkedIn post laid out the misunderstanding. The CRO thinks we’re a reference and speaker desk. PMM thinks we just produce evidence. CS thinks we hand out swag and inflated titles to customers. The CMO thinks we’re tactical at best, not strategic. And almost everyone collapses the entire function into customer advocacy, which is one of seven pillars.

The fix is two things, not one. Define the function. Then educate continuously, because bias doesn’t correct itself.

Part one: define the function

Every customer marketing leader should be able to answer four questions in one breath:

• What are the seven pillars of customer marketing?

• Which two or three is your team actually running today?

• Where is the gap between what you run and what the business needs?

• What does customer marketing orchestrate at scale that no other function can?

If you can’t answer those, the function is whatever the loudest stakeholder said it was last quarter.

The seven pillars:

→ Lifecycle and adoption: getting customers to value faster after the sale

→ Customer advocacy: turning happy customers into proof and pipeline

→ Community: building peer-to-peer trust at scale

→ Customer education: making the product easier to master

→ Customer communications: keeping customers informed and engaged

→ Voice of customer: surfacing insight back to the business

→ Executive engagement: building trust at the top of the account

Most teams run two or three of these well and get blamed for not delivering on the other four. It’s not just a performance problem but how we define what we do with our stakeholders.

The deck every customer marketer should build in the first 30 days of any role is simple.

• Page one is the seven pillars.

• Page two is what the team is investing in this year and why.

• Page three is what the team is explicitly not doing and why.

• Page four is what would change if the team had one more headcount, one more dollar, or one more quarter.

• Page five is the orchestration claim.

The orchestration claim is the line that changes the room. Customer marketing orchestrates GTM at scale because no other function sits closer to the customer. Every play and every program runs through us. None of it works without the customer at the center.

That’s the definition. Print it. Use it.

Part two: educate continuously

Definition gets you the room. Education keeps you in the room.

Here is the truth nobody tells new customer marketing leaders. You will define the function in your first 30 days, and six months later you will sit in a meeting where someone confidently describes your team as “the case study people.” That person was not in your kickoff. They joined three months ago. They built their view from a single interaction with one of your team members or from their prior work history.

You don’t get angry. You educate.

Educating continuously looks like this in practice:

Open every QBR with a 90-second restatement of what customer marketing is and what it’s investing in this quarter. Not a recap of work delivered. A restatement of scope. Same slide, every quarter. Boring is the point.

Build a one-page customer marketing charter that lives in the company wiki, in your team’s Slack channel topic, and in the appendix of any deck you present cross-functionally. New hires find it. Skeptical execs find it. You stop having the same conversation in DMs.

Pre-brief every new exec in their first 60 days. Twenty minutes. What we do, what we don’t do, what we need from your function, what your function should expect from us. If you wait for the misunderstanding to surface in a leadership meeting, you’re already losing.

Train your own team to articulate the function the same way you do. If your manager describes customer marketing as “running advocacy and the community” and your director describes it as “lifecycle, advocacy, community, education,” your team is already misaligned. Pick one definition. Use the same words. Repetition is the only thing that changes how a function is understood.

Translate every program into the language of the stakeholder you’re talking to. CS hears retention and adoption. Sales hears pipeline influence and references. PMM hears proof and launch enablement. CRO hears revenue impact and CAC payback. Same work, different framing. The work doesn’t change. The translation does.

The pattern under all of this is simple. You are the curator of how the function is understood inside your company. Nobody else is going to do that job for you. The CMO won’t. The CRO won’t. Your peers won’t. The moment you stop educating, the definition starts drifting back to whatever the loudest stakeholder needs from you this quarter.

The one mistake to avoid

The biggest mistake customer marketing leaders make is treating the definition conversation as a one-time exercise. They write the charter, present it once, and assume the org has internalized it. Six months later they’re frustrated that nobody understands the team’s scope, and they take it personally.

It’s not personal, organizations are in constant flux and leaders are context switching 20+ times a day. We need to make it easier for them to remember us which is why I also created this app in claude code as your cheat sheet on what CLG is and how to tell that story. Companies onboard new execs, restructure teams, change priorities, and forget. The function gets re-defined by attrition every quarter. Your job is to keep redefining it back to the truth.

Define it. Then educate forever.

Next week

Issue 19 takes on the salary and structural ceiling that nobody in customer marketing wants to talk about. The data from UserEvidence’s salary study shows 78% of CMA professionals want to advance, but only 12% have a clear path. We’ll walk through what that means for your career, the moves that close the gap, and the move nobody mentions: leaving on time.

Talk soon,

— Kevin

I built this program at Marketo in 2017.

It helped make Marketo irresistible to Adobe in a $4.75B acquisition.

Then I scaled it at Adobe. Then rebuilt a version at Freshworks. Three companies. Three iterations. Every time it produced results that outpaced anything else we built.

This week’s newsletter tells the full story including an article I wrote in 2019 and never published until now.

Paid subscribers get two assets I have never shared publicly before:

Read more

If this newsletter has brought you value, the best thing you can do is forward it to one person who needs it. It takes ten seconds and it means everything.

Adobe Summit just wrapped up yesterday in Las Vegas.

I still have a ton of colleagues and friends that went which is probably why I’m thinking about it more than usual.

For several years, Summit was the centerpiece of everything we built. The stage where our Champions spoke. The conference we once had twelve weeks to merge with an entirely different event. The moment that tested everything we had built and proved it was real.

So this week felt like the right time to finally publish something I wrote six years ago and never shared. If you read until the end, there’s a special bonus for paid members.

In April 2019, the week after Adobe Summit, I sat down and wrote about the program that had defined the previous two and a half years of my career. I wrote it while everything was still fresh: the energy, the chaos, the emotion of what we had just pulled off.

Then I closed the document and never published it.

I am not entirely sure why. Maybe it felt too personal. Maybe the story was not finished yet. Maybe I knew, even then, that what we had built was still becoming something I did not fully understand.

Reading it now, six years later, I think I was right. The story was not finished. It is still not finished. One of the Champions I mention in that article is now at Adobe. Another went on to speak at Summit five times. Several of them became lifelong friends and collaborators who shaped my career in ways I am still discovering.

So here is the article. Exactly as I wrote it in 2019. With one addition at the end: the part of the story I could not have written then.

“We #BleedPurple” — A Recipe for Building Best in Class Customer Experiences

Written April 2, 2019. Never published. Until now.

“Our customers #bleedpurple.”

That was one of the first things I heard when I joined Marketo nearly two and a half years ago. I did not understand the phrase at first. I quickly came to realize that Marketo’s Marketing Nation was one of the most vibrant, passionate, and diehard fanbases in the world.

My challenge was how to take an already extraordinary community of customers and reimagine how we engaged them across our advocacy programs at scale.

These programs included the Marketing Nation Community, Marketo User Groups, Purple Select, the Champions, third party reviews, a reference program, customer success stories, the Fearless 50, and Summit and customer events.

These programs would later become part of a larger initiative called the Advocate Nation, launched in 2018 to give customers ongoing opportunities to build their personal brands, network with peers, and earn recognition for their participation.

The recipe for advocate growth

To build best in class programs, you need a recipe.

One part engagement platform. Two parts opportunities for personal branding: thought leadership, speaking, and blogging. Three parts active listening and proactive outreach with customers. Four parts gamification, recognition, and rewards. Five parts purple swag. A pinch of good luck. And a dash of surprise and delight, what I used to call shock and awe campaigns.

That is the foundation for cultivating an army of loyal advocates. And if you really want to accelerate growth, work closely with your biggest brand ambassadors when making decisions.

Enter the Marketo Champions

It is hard to imagine a time before the Marketo Champions.

Even before I joined Marketo, I had heard of this legendary group of 60 expert practitioners who had to apply each year for a chance to be named a Champ. It was not just the title: these people genuinely knew their Marketo.

The community recognized them as true experts at their craft.

Honest, loyal, and deeply passionate about the work. For the most part we could have continued operating just as we had and nothing would have changed. But for programs to go from good to great to exceptional, we needed new thinking, new perspective, and a customer-first mentality.

So I went down a rabbit hole of conversations with Champions; what was working, what was not, where we could go next.

It became clear that to scale our advocacy initiatives we needed to be more customer centric. We needed to use our Champions across the entire customer journey, not just in one lane.

That is when the transformation began.

We partnered with the Champions to create a new program charter outlining the criteria for future classes and launched a Leadership Committee to give power back to the members. Making sure their feedback was recognized and heard was critical to the program’s success.

Around the same time our charter in Customer Marketing expanded to incorporate adoption initiatives, helping customers to be more successful using Marketo. By providing both advocacy and adoption opportunities, we were able to accelerate not only the program’s awareness but also our impact to the business.

The Advocate Nation grew by over 50% in the first three months. Champions contributed regular content to our customer nurture programs. And then, when Adobe told us we had twelve weeks to merge Marketing Nation Summit with Adobe Summit, the Champions made the impossible possible.

From start to finish they provided expert advice on what would resonate with customers, helped drive attendance, led some of the top performing breakout sessions, drove four times the number of Revvie Award applications (eventually called the Adobe Experience Maker Awards) in under six weeks, and contributed to main stage keynotes.

Early in my career I learned from one of my mentors, Mari Smith, that to create exceptional experiences you need to put your faith, love, and trust in people.

That is exactly why I love this work. We get to see the direct result of our efforts in helping customers be successful, grow their careers, and train the next generation of marketers.

Magic moments are forged when you bring the right people and experiences together.

Champions, thank you for inspiring me and the next generation of fearless marketers everywhere. Your biggest cheerleader will always be here watching.

— Written April 2019

What I could not have written then

When I wrote that article, one of those 60 Champions was a woman who had made one of the most unlikely career pivots I had ever seen.

She had started as a PhD student in cancer biology at Stanford. Somewhere along the way she discovered marketing operations and taught herself Marketo. She became a Marketo User Group Leader, then a multi-year Champion, then a Revvie Award winner, then a Summit speaker. She spoke on that Summit stage in 2019 even while 7 months pregnant because she was that passionate about Marketo.

We worked together again at F5, where she was Senior Director of Marketing Operations. Then she went to Cloudflare as Senior Director of Demand Operations.

And then, in one of those moments that makes you believe the universe has a sense of humor, she went to work at Adobe. The company that acquired Marketo. The stage she first spoke on in 2019. Full circle.

Her name is Jess Kao. In the Adobe universe, she’s a true celebrity. And her story is not a footnote to the Champions program. It is the point of it.

The program did not just produce references and case studies and Summit speakers. It produced a decade-long friendship and a career trajectory that neither of us could have predicted when she first raised her hand to be part of something we were still figuring out.

I have been thinking about this a lot lately.

The programs end. The companies change. The titles come and go.

The relationships compound.

That is not a tagline. It is the truest thing I know about this work.

Next issue: what happened inside those twelve weeks when we had to move an entire conference, and what 60 skeptical Champions taught me about leading through uncertainty.

— Kevin

P.S. The Champion Program Charter we used to build this program is available to paid subscribers. Not a template. Not a recreation. A sanitized version of the actual charter from the program that became a model for advocacy programs across the industry. If you want to build something that lasts, you can access it here.

If you get value from this newsletter, the best thing you can do is forward it to one person who needs it. It takes 10 seconds and it means everything.

Everyone is talking about agentic-led growth right now.

Agents that sell. Agents that onboard. Agents that expand accounts autonomously, priced on outcomes, not seats.

Mark Benioff calls it “service as software, not software as a service.” The shift is real and it is coming for every post-sale function.

But there is something missing from most of the conversation.

Agents cannot earn trust. That is still a human job.

And here is the part most people are skipping: before you add agents to your post-sale motion, you need to understand what infrastructure those agents actually depend on to work.

That infrastructure has a name. It is the Customer-Led Growth (CLG) system.

This issue is about what I built to show exactly how agents and CLG connect, and how you can use it before your next planning conversation.

What I built

The CLG Flywheel app that I built in claude code now has a new tab: the CLG Agentic Blueprint.

It is a fully interactive architecture diagram showing what a complete agentic CLG system looks like: from human strategy at the top to tech stack at the bottom. Five layers. Seven pillars. 135 agents. Six orchestrators connecting everything. I created it because I wanted to show a real diagram to help explain how all these agents can work together to help you address some of the biggest painpoints or obstacles that often impact our ability to do our job: building relationships and engaging customers.

Here is how it is structured.

Layer 1 — Human Strategy

Seven human leads sit at the top of the architecture: Community Lead, Lifecycle Lead, VoC Lead, Advocacy Lead, Comms Lead, Education Lead, and Exec Engagement Lead.

These are not roles being replaced by agents. They are the roles that become dramatically more powerful because of agents. Judgment, relationships, and business case ownership still live here. Agents free these people to focus exclusively on what only humans can do.

Layer 2 — Orchestration

Six routing engines sit between human strategy and agent execution. This is the layer most teams miss entirely.

The CLG Signal Router ingests signals from all pillars and routes them to the right agent cluster. The Revenue Attribution Engine maps CLG program activity to pipeline, expansion, and retention outcomes. The Account Intelligence Hub aggregates account-level signals into a single 360 view. The Proof Library Orchestrator routes customer evidence to the right deal, campaign, or channel. The Rewards Fulfillment Orchestrator triggers rewards when advocacy acts hit thresholds. The Comms Governance Controller enforces send limits and prevents communication overload across all systems.

Without this layer, agents work in silos. With it, they work as a system.

Layer 3 — Agent Execution

135 agents across 7 pillars. Each pillar column is expandable, click any pillar to see every agent in it, what it does, and what it writes to.

A few examples of what lives here:

• The Champion Scout Agent scans community activity for advocacy-readiness signals and surfaces the right customers before your team even thinks to ask.

• The At-Risk Flag Agent combines login drop, NPS movement, and support escalations into a single churn risk score and routes it to the right CSM with a recommended next action.

• The Sentiment Cluster Agent groups NPS verbatims, support tickets, and review content by theme and delivers a weekly brief to your product and VoC teams.

• The Reference Match Agent matches open deals to the best-fit customer references by industry, use case, and deal stage in seconds, not days.

• The Briefing Prep Agent generates pre-meeting exec briefs from health scores, usage data, and relationship history before every EBR or CAB.

• These are not hypothetical. Every agent in the blueprint has a name, a trigger, a data input requirement, an output, and a recommended platform.

Layer 4 — CDP / Data Backbone

Every agent action fires an event. Every event is captured. Every record stays current.

This layer shows how the data flows: what feeds into the CDP, what the CDP writes out to your systems of record, and which platforms handle it. Segment, Rudderstack, mParticle, Treasure Data on the CDP side. Snowflake, Databricks, BigQuery, Redshift on the warehouse side. Real-time writes to Salesforce, Gainsight, your advocacy platform, and your analytics dashboard.

Without this layer, your agents are working from stale data. That is where agentic motions break down.

Layer 5 — Tech Stack

Fifteen categories of platforms that agents read from and write to. CRM, Customer Success, Advocacy, Community, VoC, Education, Content, Marketing Automation, Rewards, Product Analytics, BI, Conversation Intelligence, Support, CDP, and Data Warehouse.

Every platform in the app’s tech stack selector is mapped here. You can customize it for your own stack. Please note that it’s not intended to be exhaustive especially as new vendors launch. If anything, this should cover the majority of the core solutions that are well known across most B2B SaaS organizations.

How to use the blueprint right now

Open clg.thecustomercontinuum.com and click the Agents tab.

Start with your lowest-scoring CLG Diagnostic pillar. Find that column in the Agent Execution layer. Expand it. Read the first three agents. Ask yourself: which of these already exist in my stack in some form, and which are completely missing?

That gap is your roadmap.

If you are heading into a planning conversation or a budget discussion in the next 30 days, screenshot the architecture and bring it. Not as a “here is what I want to build” slide. As a “here is what best-in-class looks like and here is where we are today” slide. The visual does the work for you.

If you want to go deeper and actually start building these agents paid subscribers to the Customer Continuum get something else entirely. I published a companion piece with the full implementation kit: eight downloadable markdown files, one for each pillar plus the CDP backbone layer, each with every agent fully specced and ready to hand to your IT team or AI strategy lead.

Free to start at clg.thecustomercontinuum.com. Upgrade for the build specs.

ACCESS THE CLG AGENTIC .MD FILES HERE

Other updates to the app this week

Beyond the Agents tab, a few things worth knowing:

The Revenue Impact Model now factors in your number of customers and average deal size alongside ARR, NRR, and churn rate. The output is a more precise directional business case.

The Company Intelligence tab has a privacy disclaimer and handles concurrent searches cleanly. Type in any company and get a CLG maturity brief in about 30 seconds.

My Ask Kevin GPT now renders markdown in responses and has a 40-message conversation limit before prompting a fresh session.

The tech stack selector now includes a CDP category with Segment, Rudderstack, mParticle, Treasure Data, Adobe CDP, Salesforce Data Cloud, and Tealium. Freshdesk is added to Support. Gong, Chorus, and Clari are added under Conversation Intelligence.

See you next Thursday.

— Kevin

P.S. The implementation kit for paid subscribers covers all 135 agents with full build specs. If you are a customer marketer who has an AI strategy conversation coming up, this is the resource that makes you the most prepared person in the room. Link above.

A lot of you asked the same question after seeing it: how do I actually build these?

That is what this kit is.

Eight Claude Code-ready MD files. One per pillar. Every agent spec includes what it does, what data it needs, what it outputs, and five specific steps to build it inside your stack.

Start with the pillar that matches your biggest problem right now.

Churn is your problem? Lifecycle and Adoption.

Sales asking for more references? Customer Advocacy.

Community has no ROI story? Community Engagement.

Agents are stack-ranked inside each file so you know exactly where to begin.

Your full kit is here.

P.S. Please make sure to read the file called “READ ME FIRST - CLG Blueprint Master Guide.md” first.

-Kevin

If you get value from this newsletter, the best thing you can do is forward it to one person who needs it. It takes 10 seconds and it means everything.

I need to come clean about something.

This weekend I did something I have never done in 15 years of working in tech.

I built a web app.

Not “I described what I wanted and a developer built it.” Not “I used a no-code tool and dragged some blocks around.” I mean I opened a terminal, used Claude Code, and built something from scratch.

15 years in marketing. Zero technical background. Zero production code before this weekend.

The hardest part was not the code. The hardest part was figuring out how to take what I had built on my computer and get it to GitHub so the world could actually see it. I spent more time on that than on anything else. The terminal. The commands. The errors that meant nothing to me. Well, almost nothing with the exception of a few painful moments.

But the back and forth with Claude Code kept me going. I would describe what was broken in plain English. It would fix it. I would move forward. That loop, human clarity, AI execution, is something I did not expect to find so compelling.

By Sunday night I had something real enough to demo in front of a room full of community practitioners at Community Week.

Here is what I built, why I built it, and why you are getting it first.

The problem I kept hitting

Every time I explained the Customer-Led Growth system: seven pillars, one engine, people got the concept immediately.

Then they hit the same wall.

“Okay, but where do I actually start?”

A framework without a diagnostic is just a slide. It tells you what the system looks like. It does not tell you where you are weak, what to fix first, or how to make the case in numbers your CFO already uses.

I kept having that conversation. So I built the thing that ends it.

What I built

Three things you can do with it right now:

CLG Diagnostic. Score all seven pillars on a 1-5 scale. Get a health score, a radar chart, and a prioritized action list. Five minutes. Free. No login.

Revenue Impact Model. Input your ARR, NRR, and churn rate. Get a directional business case for investing in the full system in language your CFO speaks. Run this before your next budget conversation.

Company Intelligence. Type in any company name. Get a CLG maturity brief across all seven pillars in about 30 seconds. I use this before executive briefings and customer conversations.

There is also a Freshworks Case Study, a Glossary, and a new revised Kevin Lau GPT tab for open-ended CLG questions.

You are getting this before anyone else. It goes public Friday.

You can also watch this short tutorial video on how to best leverage the app below:

»»»ACCESS THE CLG FLYWHEEL«««

What the build actually taught me

The bottleneck was never the technology. Claude Code handled that.

The bottleneck was always clarity. What should this actually measure? What makes a health score meaningful and not arbitrary? What does the action list need to say to be genuinely useful?

Those questions only I could answer. And wrestling with them forced me to get more precise about the CLG system than any deck or document ever had.

But the bigger lesson was not about the framework.

It was about what is possible.

I walked away from that weekend thinking about the glass as half full in a way I did not expect. We can move faster than we think. We can build things we never imagined building. The only real ceiling is how clearly you can articulate what you want.

That is not a small thing. Most of us have ideas sitting in a notes app or a back-of-mind folder that we have written off because we assumed we needed something we did not have: a developer, a budget, a team, a timeline.

The model has changed. You bring the domain expertise. AI handles the execution. Neither of you builds this alone. Together you build something neither of you could have made otherwise.

If you have been sitting on an idea, Claude Code is worth an afternoon. The barrier is lower than you think. The bottleneck is your clarity, not your skill set.

How to use it this week

Run the diagnostic. Look at your radar chart. The biggest gap is your roadmap: not one I hand you, the one your own data reveals.

If you have a budget conversation in the next 30 days, run the Revenue Impact Model first. Three minutes. One number.

Reply and tell me your health score. I read every reply. Genuinely curious what the data shows across different company sizes and team structures.

And if you have feedback on how I can improve the app, by all means please tell me.

— Kevin

P.S. You got this before anyone else. If it is useful, forward it to one person fighting the same budget conversation you are. That is how this newsletter grows. One practitioner to the next.

The VP Accelerator is a 90-day program for Senior Managers and Directors ready to make the move to VP. Reply “Accelerator” and I will send you details.

If you enjoy The Customer Continuum, it would mean the world to me if you invited friends to subscribe and read with us. If you refer friends, you will receive benefits that give you special access to The Customer Continuum and new things that I build and develop for our community.

How to participate

1. Share The Customer Continuum. When you use the referral link below, or the “Share” button on any post, you'll get credit for any new subscribers. Simply send the link in a text, email, or share it on social media with friends.

Refer a friend

2. Earn benefits. When more friends use your referral link to subscribe (free or paid), you’ll receive special benefits.

• Get a 1 month comp for 3 referrals

• Get a 3 month comp for 5 referrals

• Get a 6 month comp for 25 referrals

Visit the leaderboard

To learn more, check out Substack’s FAQ.

Thank you again for subscribing and please do let me know how else I can best serve you in the future.