DEV Community: Paolo Bruschi

The Self-Improving Sales Process: The Compounding Effect, Applied to Sales

Paolo Bruschi — Sat, 30 May 2026 12:24:46 +0000

The modern sales org is not designed to learn. It is designed to report what happened after the fact.

That made sense when humans had to inspect the work, summarize the pattern, and decide what should change next. It makes less sense now when AI can turn sales management into a feedback loop itself: a system that observes what happened, advises on the next best move, measures the result, and improves the motion without waiting for the next forecast call.

A few days ago I watched a Y Combinator talk by Tom Blomfield, the founder of Monzo and now a YC group partner. It put language around something I had been feeling for weeks: the future sales org will not be a bigger hierarchy with better tools. It will be a smaller, sharper set of self-improving loops.

Blomfield was synthesizing a body of ideas pulled from several places: a thread from Jack Dorsey on how hierarchical companies are organized, work from his YC colleague Diana Hu on what she calls "AI loops," and an essay from Pete Koomen on why most companies are still using AI the wrong way. I kept translating every example into sales, because if there is one corner of the modern company still committed to humans-as-information-conduits, it is the sales organization.

This piece is my synthesis of that argument, what I think it means specifically for sales leaders, and the experiment I'm about to run to find out whether it actually works.

The sales org is the most Roman thing we still build

The Roman legions were engineered to project power across two continents. The mechanism was a nested hierarchy with consistent spans of control: named individuals at each level passed orders downward and reported observations upward. The chain was the information system. Jack Dorsey's framing, picked up by Blomfield in the talk, is that almost every modern company is still built on this assumption: that human beings are the conduit through which information flows up and down.

Look at a modern sales org. SDRs report to SDR managers. AEs and BDMs report to regional managers. Regional managers report to a VP. The VP reports to the CRO. Information moves up the chain in the form of CRM updates, forecast calls, weekly pipeline reviews, and Friday commit emails. Targets, playbooks, and rules of engagement move down. The humans are the bus, and the bus is slow. CRM updates arrive late. Each SDR and BDM has a different level of hygiene. Deal context gets fragmented across notes, calls, Teams messages, and memory. By the time the data is clean enough to trust, you often need weeks or months of observations just to make sure the signal is real and not background noise.

We have never seriously questioned this structure. We've layered tooling on top of it, from Salesforce and HubSpot to Gong, Apollo, and Outreach, but the underlying assumption that humans are the conduit has stayed intact.

That assumption is the thing AI breaks.

The wrong way to do AI in sales

A year ago, if you asked sales leaders what AI was doing for them, you'd get the same set of answers. Gong summaries. Apollo enrichment. CRM copilots that auto-fill activity logs. Sequence generators. AI SDRs that send the same cold email a human SDR would send, just at higher volume.

This is what Pete Koomen called the "horseless carriage" framing. We take the existing motion and bolt a faster engine onto it. The reps ship more activity. In a landmark 2023 study of more than 5,000 customer support agents, Brynjolfsson, Li, and Raymond found generative AI tools delivered a 14% productivity gain on average, climbing to 34% for novice workers. Useful, but the shape of the org doesn't change.

That framing is the thing to abandon. Not because the tools are bad, most are genuinely useful, but because they leave the architecture untouched. You still have the Roman legion. It just runs on caffeine instead of water.

Goldman Sachs' Jim Covello tracked exactly this dynamic across two years of enterprise AI deployments and concluded that 95% of organizations were getting zero return on their AI pilots despite $30–40 billion in spend. That isn't an AI problem. It's an architecture problem.

The interesting move is to stop bolting AI onto the sales org and start asking what the sales org would look like if it were redesigned around AI from the ground up. The answer, I'm increasingly convinced, is: a set of recursive, self-improving loops, with humans only at the edges where they actually add value.

The shape of a self-improving sales loop

Every self-improving loop has the same skeleton. Diana Hu has written about the canonical structure; translated into sales terms it looks like this:

Sensor layer. Call recordings, email threads, CRM stage changes, win/loss notes, prospect website visits, intent signals, opened proposals, response latency. Anything that tells the system what happened.

Policy layer. Rules about what the system can do on its own versus what it must escalate. Update the CRM autonomously. Draft a follow-up, always. Send it unsupervised below €1k MRR; flag for human review above. Never offer a discount without a human signoff.

Tool layer. Deterministic APIs the agent can call. Query the CRM. Score a lead. Look up a contact on LinkedIn. Read the calendar. Book a meeting. Push a deal stage forward.

Quality gate. Evals on email tone, factual accuracy, brand voice. Human review on anything above a price threshold. Sampling reviews of autonomous decisions to catch drift.

Learning mechanism. Did the meeting book? Did the deal progress? Did the prospect respond? Did we win? When we lost, why? Every outcome feeds back to the top and shapes the next iteration.

The part most sales tooling misses is the last one. The loop has to close without a human in the middle of every cycle. The human supervises at the edges. The loop runs on its own most of the time, and improves itself while the team is asleep.

The flagship loop: SDR → BDM → close-rate self-improvement

This is the loop I'd start with, and it's the one I'm planning to test next.

The SDR-to-BDM handoff is the single highest-leverage moment in most B2B sales orgs. SDRs generate opportunities. Some of those opportunities convert into closed-won deals; most don't. The standard explanation, "the SDR didn't qualify well enough" or "the BDM didn't work it hard enough," is almost always too coarse to act on.

What if you ran the handoff as a self-improving loop?

Sensor. Every SDR-sourced opportunity, with the qualification call recording, the discovery notes, the prospect's stated pain, the SDR's MEDDIC scoring, the company firmographics, and the eventual close-rate outcome.

Policy. The agent can update SDR playbooks, propose new qualification questions, rewrite the ICP definition, and flag SDRs whose opportunities consistently underperform. It cannot fire anyone or change comp.

Tools. Query the CRM. Pull the call transcript. Pull the BDM's discovery notes. Score the alignment between SDR-claimed pain and BDM-discovered pain.

Quality gate. A weekly human review of any proposed playbook changes before they ship. Sample-check 10% of autonomous CRM updates.

Learning. For every closed deal, the agent runs a post-mortem: which signals at the SDR stage actually predicted the win? For every loss, the same question in reverse: what did the SDR claim that turned out to be wrong? Over time, the agent updates the SDR's qualification framework, not the high-level MEDDIC template the entire industry copies, but the specific version that works for this product, this market, this BDM team.

The compounding effect is the interesting part. After a month, every SDR is qualifying with a sharper framework than the one they had a month ago. After three months, the framework is custom-fitted to your actual win patterns. After a year, the SDR team's productivity has moved less because of any individual rep and more because the playbook itself has become smarter every night.

This is the loop I want to run. I'm starting in the next few weeks, and I'll write up what worked and what didn't.

Other sales loops worth running

Once you see the pattern, you see it everywhere.

Discovery quality loop. Which discovery questions correlate with deals that close vs. deals that stall? Update the discovery framework weekly.

Objection handling loop. Which responses to "you're too expensive" lead to closed-won outcomes? Which kill the deal? Build a living objection library that reorders itself based on what actually works.

Outbound sequence loop. A/B test sequences continuously. Pick the winner. Replace the loser. Repeat. No quarterly sequence reviews; the system runs the experiment for you.

ICP loop. Every closed-won and closed-lost deal feeds the ICP definition. Companies that look like your actual best customers, not the ones in your founder's head, get more outbound attention.

Deal-risk loop. An agent watches every open deal for early warning signs (champion went quiet, no proposal opened, calendar slip on the next meeting) and surfaces the at-risk list every morning, with suggested recovery moves.

None of these are theoretically novel. Sales leaders have talked about all of them for years. The thing that's new is that you can now run them without a full-time analyst, without a project, without a quarterly review cycle. The loop runs itself.

What this means for sales leaders

A few implications I think are non-negotiable.

Burn tokens, not SDR headcount. Blomfield's talk noted that YC companies are now reaching demo day with roughly 5x the revenue per employee they had eighteen months ago. CNBC reported the broader shift in March 2025: YC's current crop is the fastest-growing and most profitable in fund history, with companies hitting $10M in revenue inside twelve months on teams of fewer than ten people, a quarter of them having 95% of their code written by AI. The binding constraint for sales orgs is about to shift from how many SDRs you can hire to how many tokens you can spend. Hire fewer, equip them with more compute, and measure who in your org is exploring the frontier of what's possible.

Every outcome should belong to a named person. Not a committee. Not "the SDR team." A single human directly responsible for each loop, each experiment, each metric. The org chart flattens. The accountability sharpens.

The CRO becomes a context engineer. The most valuable thing a sales leader can do in the next twelve months is make the organization legible to AI. The leader who does this fastest will compound.

How to make your sales org legible

This is the prerequisite for everything above, and most sales orgs are nowhere close.

Record everything. Every call. Every demo. Every discovery session. Every internal pipeline review. Every Teams message about a deal. If it wasn't recorded, it didn't happen, as far as the AI is concerned. Most sales orgs already have Gong or Chorus and don't realize they're sitting on the most valuable training data in the company.

Force CRM hygiene. Not because the CRM is a beautiful artifact, but because a deal whose state isn't written down is invisible to every loop. The rep who keeps deal context in their head is the rep whose pipeline can't be learned from.

Synthesize, don't dump. You can't feed 10,000 hours of call recordings into a model. You diarize them. You categorize them by deal stage, by objection type, by industry. You compress them into a living playbook, one that regenerates itself monthly from the new recordings, the same way YC just rebuilt its founder user manual from 2,000 hours of office hours.

What humans are for in this new shape

Think of the sales org as a brain. The data, the call recordings, the playbooks, the deal history, the qualification frameworks, that's the brain. The humans sit around the edges, interfacing with reality.

Humans go where the models can't yet, and where they probably won't for a long time:

The high-stakes closing meeting where the customer wants to feel a person across the table.
The executive sponsor relationship where trust is the currency.
The dinner where the deal actually gets closed.
The champion management call when the deal is wobbling and the champion is wavering.
The negotiation when the customer asks for something the policy layer doesn't cover.
The on-site visit. The conference floor. The kickoff.

That work stays human for the next twenty years. The institutional view is starting to confirm this. In August 2025, Gartner published a forecast that by 2030, 75% of B2B buyers will prefer sales experiences that prioritize human interaction over AI, a reversal of the digital-first narrative Gartner itself was pushing five years earlier.

The job of the sales leader is to make sure the humans are spending their time on exactly those moments, rather than on CRM hygiene, weekly forecasting spreadsheets, or coaching reps through the eighth iteration of the same objection-handling drill.

The replacement myth

Most sales leaders think AI is here to replace salespeople. I think that's the wrong fear. AI doesn't replace the people; it removes the people from the connective tissue between tasks, so the ones who remain spend all their time on the decisions that actually close deals.

The roles that disappear first aren't the closers. They're the coordinators, the routers, the summarizers, the people who exist because information needed a human to carry it from one task to the next. Those roles are the Roman legion's signal corps, and AI is a much better signal corps than humans have ever been.

The closer stays. The discovery rep stays. The executive sponsor stays.

The clearest evidence is already on the table. 11x.ai, the most heavily funded AI-SDR company in the category and backed by $74M from Andreessen Horowitz and Benchmark, claimed $14M in ARR. After trial conversions, the actual figure was closer to $3M. ZoomInfo, one of its largest reference customers, publicly stated that 11x "performed significantly worse than their SDR employees." Customer churn ran 70–80% within months. The category has not produced a single durable example of AI replacing the closer or the qualifier, only examples of AI replacing the coordinator between them.

What collapses is everything that sat in between them, slowing the loop down. The sales org doesn't get smaller because AI does the selling. It gets smaller because AI does the connecting, and the selling, the part that actually requires a human, becomes a larger share of every salesperson's week.

That's the bet under everything else in this piece. Get it right and you don't downsize your team. You concentrate it.

The bet I'm about to make

I'm starting the SDR-to-BDM self-improving loop on my own team in the next few weeks. I'll instrument the handoff, wire the post-mortem agent into the close-rate data, and let it propose playbook updates weekly. The control group is the current playbook. The treatment group is whatever the loop produces.

I'll report back on what worked, what broke, and where the loop drifted off-strategy, because I'd be lying if I said I expected it to work cleanly on the first try. The interesting question isn't whether the loop produces a better playbook on day one. It's whether it produces a better playbook every week, and whether that compounding effect actually shows up in the numbers.

If it does, the implication for sales leaders is straightforward: stop hiring your way to the next number. Start building loops.

If it doesn't, I'll tell you exactly where it failed.

Either way, this is the direction the field is moving. The sales orgs being built right now in this new shape will outproduce the legions. The only question for the rest of us is how quickly we're willing to rebuild.

Sources

Tom Blomfield, How to Build a Self-Improving Company with AI, Y Combinator — YouTube
Pete Koomen, AI Horseless Carriages — koomen.dev
Erik Brynjolfsson, Danielle Li, Lindsey Raymond, Generative AI at Work, NBER Working Paper 31161 — nber.org
Goldman Sachs, Gen AI: Too Much Spend, Too Little Benefit? — goldmansachs.com
CNBC, Y Combinator startups are fastest growing, most profitable in fund history because of AI (March 2025) — cnbc.com
Gartner, By 2030, 75% of B2B Buyers Will Prefer Sales Experiences That Prioritize Human Interaction Over AI (August 2025) — gartner.com
The AI SDR Wars: 11x.ai competitive teardown — useanterion.com

How a Self-Improving AI Loop Increased Our SDR First-Touch Volume by 139%

Paolo Bruschi — Sat, 30 May 2026 12:20:04 +0000

Most outbound machines are dumb loops. The SDR sends emails, some get opened, a few get replied to, and at the end of the week a sales manager asks how it went. The SDR says fine or not fine. Adjustments get made based on gut feel. The same mistakes get made next week because nobody was measuring what specifically changed and why.

The reason this happens is not because sales leaders do not care about data. It is because the data collection, the filtering, the week-over-week comparison, and the learning capture all require manual work that nobody has time to do rigorously. So it does not get done. The loop stays dumb.

Over the past two months I have been building a version of this loop that learns. It is not one agent — it is two, working in sequence. One handles the research and prospecting quality. The other reviews what happened, measures what changed, and checks whether the team is applying the lessons. Together they produced results I can now put numbers to.

First-touch outbound volume went from 9.7 emails per business day to 23.2 — a 139% increase. Bounce rate dropped from 2.76% (above our alert threshold) to 1.18%. Our SDR went from running a single generic sequence to seven personalised entry-point variants. And for the first time since we started measuring against our new benchmark, we hit a GREEN day — clearing both the daily email target and the unique-companies-reached target in the same session.

This is the story of how that happened, what the system actually looks like, and what it took to make it work.

The two-agent system

The outbound machine has two moving parts.

The first is the Outbound Campaign Agent. It runs before a prospecting push. It researches each prospect, identifies buyer intent signals, pulls CRM data on dormant and re-engagement opportunities, and produces a ranked prospect list with personalised opening angles for each contact. When the SDR sits down to start a sequence, they are not writing generic emails to a cold list — they are sending specifically calibrated outreach based on what the agent found. The quality of the research feeds directly into the quality of the opening line, which feeds directly into the reply rate.

The second is the SDR Debrief Agent. It runs every Friday. It reviews what happened the previous week — which emails were sent, which sequences they belonged to, which touch stage each contact was at, how the engagement metrics moved — and produces a structured report before the weekly team debrief. It also maintains a learning loop: when a pattern proves durable enough to become a playbook rule, the agent tracks whether the SDRs are actually applying it week over week.

Neither agent alone produces the results we have seen. The Campaign Agent improves the input quality. The Debrief Agent closes the learning loop. The combination is what compounds.

Why I built the debrief agent when I did

The honest reason is pressure. Our inbound pipeline was underperforming and we had decided to make outbound work harder. When we looked closely at what was actually happening, we found that each SDR was running their own sequences in their own way, making changes without structure, and lessons from one campaign were not carrying over to the next.

We had dashboards that showed raw numbers, but they mixed outbound prospecting with customer correspondence, follow-up steps fired automatically by the sequence engine with genuine new first-touch sends, and active sequences with dormant ones. We were flying blind with an instrument panel we thought we could trust.

The first thing I had to fix before writing a single line of the agent was the data. This took longer than the agent itself. The CRM stores many types of outbound emails under the same object type, and pulling only genuine first-touch prospecting required mapping each sequence template ID to its correct step, building exclusion filters for customer and internal correspondence, and running manual verification samples until the output was clean.

The lesson: the data problem is always harder than the agent problem. Anyone building something similar should budget more time here than they think they need.

What the debrief agent actually does

Once the data foundation was solid, the agent runs in five stages every Friday morning.

Stage 1 — Data pull and filtering. The agent pulls all outbound emails sent by the SDRs during the target week and applies layered filters to isolate genuine prospecting emails from everything else. A random sample of five emails is surfaced for manual verification every run — the ongoing calibration step that keeps the filter accurate as the team introduces new sequences.

Stage 2 — Cohort assignment. Every email is assigned to the ISO calendar week it was sent. This is the foundation of honest measurement. Because replies and meetings arrive days or weeks after an email is sent, you cannot evaluate engagement on current-week sends. Each cohort gets measured again as the data matures: seven days for open rates, twenty-eight days for reply rates and meetings booked.

Stage 3 — Metric computation. Engagement is measured per touch stage, per sequence, per SDR, per country, and per recipient role. The north-star metric is always meetings booked from outbound — not sends, not opens. The daily activity bar tracks first-touch emails per day and unique companies reached per day against the agreed targets. Crucially, only genuine first-touch sends count toward the bar — not the sequence engine's automated follow-ups.

Stage 4 — Rolling baseline comparison. Each metric is compared against a four-week rolling average. A movement qualifies as significant only if it passes both a standard deviation test and a minimum threshold: five percentage points for rates, twenty percent relative change for counts. Below that bar, it is noise.

Stage 5 — Candidate lesson generation. When a pattern is significant and large enough to generalise, it surfaces as a candidate — not a recommendation. The human reviews it, discusses it with the team, and decides whether to apply it. Only then does it enter the playbook.

The two design choices that determined whether this was useful

Anyone with CRM access and a capable model could build a version of this in a few days. What separates a useful version from a useless one is two decisions.

Cohort Maturity Windows. The temptation, every week, is to measure engagement on emails sent this week. The data is right there. It looks meaningful. It is not. Reply rates and meeting-booked rates need twenty-eight days to stabilise. If you draw conclusions from immature data, you will change things that were working and hold on to things that were not. The agent only surfaces recommendations from cohorts at least twenty-eight days old. Current-week data is shown as in-flight — visible but not actionable.

This felt conservative in the early weeks. By week five, when the first statistically valid recommendations started arriving, it felt correct.

The Feedback Compliance Loop. Once a lesson is confirmed and shared with the SDRs, the agent does not forget it. It adds the lesson to a structured file with a machine-checkable rule and measures compliance every subsequent week. The sales coaching failure mode — rep agrees in the meeting, changes nothing in practice — becomes visible as data rather than a vague feeling. If compliance drops below target for three consecutive weeks, it surfaces as an escalation. The conversation shifts from "I think you might not be doing this" to "compliance has been at 40% for three weeks — let's talk about what's blocking it."

This was the design choice that surprised me most with how much it mattered. The feedback loop without the compliance check is just a journal. The compliance check is what makes it a coaching system.

What changed in the first 30 days

The numbers I shared at the top did not come from the Debrief Agent alone. It is worth being precise about what drove what.

The +139% increase in first-touch volume came primarily from measurement clarity. Before the Debrief Agent, the daily activity bar counted all outbound emails — including the sequence engine's automatic follow-ups, customer correspondence, and manual thread replies. The SDR appeared to be hitting targets. What was actually happening was the engine doing most of the sends while genuine new prospecting sat at 9-10 emails per day — well below the 25-30 target. Once the bar was reframed to count only genuine first-touch sends, the real baseline became visible. The improvement — to 23 per day over the last two weeks, and 27.6 in the most recent week — came from the SDRs adjusting their actual new-prospecting behaviour once they could see the real number.

The sequence sophistication — from one generic opening angle to seven personalised entry-point variants — came from the Campaign Agent improving the research quality. The SDRs were not just sending more emails. They were sending better ones, anchored to specific signals: a company scaling its team, a new ERP rollout being managed alongside new headcount, a multi-entity structure with project tracking complexity. This is what happens when the prospecting research is done by an agent that knows what signals to look for, rather than by a rep with thirty minutes before the call.

The -57% bounce rate reduction came from deliverability cleanup that the Debrief Agent made visible. At 2.76%, we were above the alert threshold that most email deliverability guides cite as the point where domain reputation starts to suffer. Once that figure surfaced weekly in the debrief with a clean breakdown of which sends were bouncing and why, it became a priority to fix rather than background noise. Within two weeks it was down to 1.18%.

The step ratio improvement — from 1:1.16 to 1:0.93 — is the metric I find most structurally meaningful.

A quick explanation of what it measures. Your sequence engine automatically fires follow-up steps on contacts already in a sequence — step 2, step 3, step 4 — without the SDR doing anything. Genuine first-touch emails are the opposite: the SDR starting a brand new sequence with a brand new contact. The step ratio compares those two numbers: first-touch sends vs. automated follow-up steps fired.

At 1:1.16, the engine was firing 1.16 automated steps for every 1 new contact being added. Consumption was outpacing replenishment. Like a bank account where withdrawals slightly exceed deposits — you don't notice immediately, but the active prospect pool slowly shrinks. In practice this means the SDR can look busy (lots of activity from the engine) while barely adding anyone new.

At 1:0.93, that flipped. New prospecting is now ahead of consumption. The pool is growing.

Most outbound dashboards never surface this. They show opens, replies, meetings — none of which tell you whether the pipeline is being built or quietly depleted. The step ratio catches that early. When it rises above 1.0 it is not a crisis today; it is a pipeline problem arriving in three to four weeks when the current sequences expire. The Debrief Agent tracks it as a structural health signal alongside the engagement metrics.

What comes next

The first fully mature cohort — twenty-eight days old, with complete reply and meeting data — arrives in early June. That is when the recommendation engine fires for the first time with statistically valid input. Until then, we have been in the baseline-establishment phase.

I will update this article at sixty and ninety days with the reply rate and meeting-booked data. If those metrics follow the same trajectory as volume and deliverability, the story compounds. If they do not, that will also be worth writing about honestly.

Results in this article reflect approximately 30 days of deployment. Updated results at 60 and 90 days will be published in the newsletter.

The deeper lesson

The agent is not the moat. The loop is.

Anyone can prompt a model to summarise last week's emails. The moat is the structured, compounding system that makes each week's data more valuable than the last — because it is being compared against a rolling baseline, interpreted through a consistent framework, and translated into lessons that get measured for compliance. That loop, once it is running, does not forget. It does not have bad weeks. And it does not let the team slide back to the habits they had before someone started measuring.

The 139% volume increase is a real number. But the more important number is week five — when the first statistically valid recommendation arrives, grounded in cohorts that are old enough to trust. That is the moment the loop stops being a reporting tool and starts being a learning system.

We are not there yet. But the trajectory is pointing in the right direction, and this time we have the data to prove it.