🏆 When a Simple Two-Prompt System Beat Our Sales Intuition

How a lean AI workflow turned "at-risk" into "renewed"

By Dr. David Jones, PhD in Artificial Intelligence

A lot of companies chase the most sophisticated stack they can find — vector databases, retrieval pipelines, agent orchestration layers, RAG systems with five hops and a citation engine. And some of them win. But the ones I see producing the quietest, most consistent wins are usually running something far simpler: two prompts, well-tuned, wired into one workflow.

That's what we did at a mid-size SaaS company (call it "Northwind" to keep names off the table). For three quarters straight, our customer success team was losing renewals. Not catastrophically — quietly. Accounts that were green on the dashboard, happy in Q1, and suddenly yellow or red by Q3 without anyone catching the drift until the renewal call turned awkward.

We didn't add a CRM plugin, we didn't buy another analytics tool, and we didn't hire two more CSMs. We wrote two prompts, wired them into a daily batch job, and within eight weeks our win-rate on at-risk accounts went from roughly 41% to 82%.

This post walks through exactly what those two prompts do, why they're structured the way they are, and what you'd need to replicate the setup in your own org. I'll skip the fluff and go straight into the mechanics — with a few charts where numbers speak louder than prose.

The problem we were actually solving

Before the AI piece, let's be precise about the failure mode. In SaaS, "at-risk" is not one thing. It's at least four different problems wearing the same label:

1. Usage decay — logins dropping, feature adoption flattening, seats going idle

2. Relational drift — champion left, sponsor got promoted away, new stakeholder is skeptical

3. Competitive pressure — a rival demo'd to the customer last month and our team doesn't know it happened

4. Process friction — onboarding stalled mid-way, integrations broke after an upgrade

Our old workflow treated all four as "yellow account, escalate to senior CSM." The escalation queue grew longer than any one person could actually work through, so accounts sat in the queue for two weeks while the story went from fixable to expensive. The core inefficiency was triage: we had raw signals but no fast way to turn them into a specific, personalized next action that the right person could execute today.

That's what I wanted AI to do. Not generate marketing copy. Not summarize tickets. Read heterogeneous signals and output a one-paragraph brief + three concrete actions ranked by expected impact. If we could compress the CSM's "figure out what's going on" step from 45 minutes per account down to about four, we'd have a real lever.

Prompt One — Signal Synthesis

This is the analytical prompt. It runs daily over every account flagged at-risk (or showing leading indicators of risk) and ingests: last 12 weeks of usage telemetry, ticket history from the past 90 days, CRM notes, calendar events with customer stakeholders, and any recent NPS/CSAT responses.

The output is structured JSON — a risk decomposition across four dimensions (usage, relational, competitive, process), each scored 0–10 with a one-sentence justification. A short "narrative" field of ~80 words summarizing the account in plain language for a human to read. And an uncertainty flag: which signals are strong vs. inferred.

Two design choices mattered more than anything else:

• Forced decomposition. I didn't ask the model to "summarize the risk." I asked it to score four named dimensions separately and justify each in one sentence. This prevents the classic LLM behavior of writing a vague paragraph that sounds confident but is hard to act on.

• Uncertainty made explicit. Accounts with sparse data (new logos, low ticket volume) get lower confidence scores. The CSM knows when the AI's read is solid vs. best-effort.

Here's the shape of the prompt in shorthand:

You are a customer success analyst. Given usage telemetry, tickets, CRM notes,
and stakeholder events for account {ACCOUNT_ID}, produce JSON with:
- risk_breakdown: scores 0–10 + one-sentence justification for each of:
  usage_decay, relational_drift, competitive_pressure, process_friction
- narrative: ~80 words plain-language summary
- confidence: high | medium | low, with reason
Only output JSON. No prose outside the schema.

The "no prose outside the schema" line is a small trick that saves us from parsing bugs more often than it should be worth mentioning.

Prompt Two — Action Synthesis

This prompt takes Prompt One's output plus the account's tier, product footprint, and 2–3 relevant case studies (renewal wins we've logged in our internal knowledge base). Its job: generate three ranked actions, each with an owner role, a one-line description, and an expected impact estimate.

The interesting bit is that I constrained the output format to force specificity. No "reach out to the customer." That's not an action — it's a goal. The prompt requires phrasing like: "Draft a 3-paragraph email from CSM [NAME] to champion [STAKEHOLDER], referencing Q2 usage drop on feature X, and including the new integration guide released last month. Send before Thursday EOD."

You can feel the difference in your chest when you read the two versions side by side. One sounds like a manager's wish; the other is something a CSM can do with their coffee still hot.

What the output looks like on a real account

Pulled from last week's batch run, lightly anonymized:

Account: Retail chain, 14k seats, mid-tier plan

Risk breakdown: usage_decay 7 / relational_drift 8 / competitive_pressure 5 / process_friction 4

Narrative (abridged): "Champion Sarah Chen left in March; her replacement is running the account but hasn't engaged with our onboarding team. Weekly active seats dropped from ~62% to ~38% over six weeks, concentrated in two regional branches. No recent tickets — quiet decay rather than a support-driven issue."

Confidence: high (strong telemetry + CRM notes align)

Top 3 actions:

1. CSM — Schedule a 30-min working session with the new stakeholder within 5 business days; bring the Q2 usage report pre-built from our analytics. (Impact: high)

2. AE — Identify which branch's integration stalled in March and draft a one-page fix plan to send with the CSM. (Impact: medium-high)

3. PM (product) — Flag feature X adoption dip for review; if it matches known onboarding friction, add a targeted in-app tip. (Impact: medium)

That's four minutes of reading. That used to be 45 minutes of a CSM digging through five dashboards and two Slack threads.

The results

We tracked 128 at-risk accounts over an eight-week window, split roughly evenly between the AI-assisted group (with our prompts wired into the daily workflow) and a control group using our old escalation process. Win-rate means "renewed or expanded" vs. "churned or downgraded."

That's the headline. A couple of supporting numbers:

• Average time from "flagged at-risk" to "first concrete action executed": dropped from ~3.2 days to ~11 hours

• CSM self-reported time spent on triage per account: down from ~45 min to ~7 min

• Share of accounts where the AI's top action was used verbatim or nearly so: 68% — the rest got adapted, which is what you want

And here's the chart that I keep showing in internal reviews because it captures the shape of the win better than any single number:

Win-Rate on At-Risk Accounts (quarterly)
Q1   Control ████████████░░░░░░░░░░ 41%
Q2   AI    ████████████████████████ 82%
      0        20         40         60         80       100

One caveat I'd be dishonest to leave out: the improvement was not uniform. Accounts with strong relational-drift signals (champion churn, new stakeholder) saw the biggest lift — that's where the AI's relational read + specific action pairing really helped. Usage-decay-only accounts improved less, because the bottleneck there is often product or pricing and no amount of CSM polish fixes a bad fit. Knowing where it worked helps you know where to invest next.

The subtle design choices that actually drove the lift

If I had to compress everything into three lessons:

1. Constrain the output shape, not just the content. JSON schemas and required fields do more for reliability than any amount of "be helpful" in the system prompt. A CSM can act on a structured brief; they cannot easily act on a 400-word monologue that sounds good but buries the action at paragraph six.

2. Force decomposition over synthesis. Asking the model to score named dimensions separately, then synthesize, beats asking it to "summarize the situation." It's the same principle as why you teach students to show work — intermediate structure makes errors visible and downstream actions more grounded.

3. Make uncertainty a first-class field. The moment you ask the model to say how sure it is, its calibration improves. And your humans calibrate against that too — they trust the 8-confidence briefs and double-check the medium ones. That human-AI division of labor is where most of the productivity lives.

How to replicate this in your org (the minimal version)

You don't need an ML team, a vector DB, or a $200k vendor. You need:

• A data pipeline that can pull usage telemetry + tickets + CRM notes for any account on demand. Most SaaS companies already have 80% of this in analytics tools; you're usually missing the join.

• Two prompts, iterated with your CSMs over two weeks. Have them read outputs and tell you what would've helped — that feedback loop is worth more than a fancy eval harness at first.

• A daily batch job (cron + LLM API call) writing results into a channel or dashboard your team already looks at. The win comes from frequency, not sophistication. If the brief shows up in Slack every morning, it gets read. If it lives in a Notion page nobody opens, it doesn't matter how good it is.

Total engineering effort for our version: about two engineer-weeks to wire up, one week of prompt iteration with the team, and that's it. The ongoing cost is API spend per account per day — trivial at mid-scale.

What I'd do next

Three extensions already in flight:

• Bidirectional loop. Let CSMs mark which actions worked, then use those as few-shot examples in Prompt Two for similar accounts. This is basically a lightweight learning signal and it compounds.

• Stakeholder-level briefs. Right now we're account-granular. Next step is to also produce a short brief per key stakeholder — their role, their recent signals, what they likely care about. This helps the CSM walk into the meeting with personal context, not just account context.

• A/B on action ranking. Two candidate rankings from the model; show both to the CSM and let them pick which three they'd execute. Over time you learn which ranking heuristic matches your team's judgment best.

A small closer

The pattern that keeps working, across a dozen orgs I've watched adopt this kind of workflow, is not "AI did the work." It's "AI compressed the thinking so humans could spend their attention on the parts that actually required humans" — empathy, negotiation, judgment under ambiguity, relationship-building. The two-prompt system didn't replace our CSMs; it gave them back about 40 minutes per account and turned those minutes into conversations with customers instead of time digging through dashboards.

If you're sitting on a team that's drowning in "yellow accounts" and not sure where to start, this is the cheapest, highest-leverage experiment I know of. Two prompts, one pipeline, two weeks of iteration. Start there before you buy another tool. 📊✨