I didn't realize how much of my sales pipeline lived in my head until I tried to make an AI use it.
On paper, I had a system.
Calls were recorded. Notes were saved. Proposals were in a folder. Follow-ups were in my inbox. Deals were tracked somewhere else.
In practice, it was four tools and me standing in the middle.
After every sales call, I did the same little dance:
- pull the call summary
- find a similar past proposal
- copy the useful parts
- rewrite it in the prospect's context
- adjust the pricing based on what I said on the call
- send it
- set a reminder to follow up
- forget
- remember three days late
None of this felt broken enough to fix.
That's the annoying part. A pipeline can be messy and still work. You can close deals while carrying half the process in memory. You can tell yourself it's fine because the calls are happening and the proposals are going out.
But there was always drag.
The proposal took longer than it should've. The follow-up was a little worse than it should've been. The next call prep depended on whether I had time to dig through old notes. If a prospect asked the same objection as three other prospects, I'd recognize the pattern vaguely, but I didn't have a clean way to prove it.
So I built the first version for my own pipeline.
The idea wasn't "replace the CRM."
I don't think most founders need another database. Most sales tools already store the deal, the stage, the contact, the expected value, the next task, and the date you were supposed to do the next task.
The part they don't handle is the selling layer.
They don't know how you write proposals.
They don't know which objections keep coming up.
They don't know what you promised on the call.
They don't know that this prospect sounds like the clinic owner from three weeks ago, and the proposal you sent that clinic is probably the best starting point.
That was the piece I wanted to test.
I built a Claude Code workflow that could read my actual sales data and produce useful work from it. Not generic "AI sales assistant" stuff. I wanted it to operate from the messy artifacts I already had:
- call transcripts
- old proposals
- follow-up emails
- closed deal notes
- objections
- pricing notes
- my own sales playbook
Then I wired the common jobs into commands.
After a call, it drafts the proposal from the transcript and past proposal examples.
Before a call, it helps prep based on prospect history or first-call research.
For follow-ups, it looks at where the deal stands and writes the next email in my voice.
After calls, it scores what happened against my own playbook and flags what I missed.
Across calls, it finds repeated objections instead of making me guess from memory.
That last part ended up being the most useful.
I pointed it at my own doctor pipeline first. It pulled 41 discovery calls and synthesized 26 unique objections, ranked by frequency.
Before I ran it, I would've bet money that pricing was the main objection.
It wasn't.
EMR integration was.
18 of the 41 calls flagged some version of it.
Pricing came in second.
That changed how I looked at the whole pipeline.
I had been treating pricing as the thing I needed to explain better. Better anchoring, cleaner value frame, clearer comparison against labor cost, that kind of thing.
But the data said prospects were getting stuck earlier.
They weren't first asking, "Is this worth it?"
They were asking, "Will this actually fit into the system my clinic already uses?"
That sounds like a small distinction, but it changes the sales work.
If pricing is the main objection, you tighten the value explanation.
If integration is the main objection, you need proof, examples, implementation detail, and probably a cleaner way to talk about edge cases.
I had been solving the wrong bottleneck.
That was the lesson for me: the objection you remember most emotionally isn't always the objection hurting the pipeline most.
Pricing objections are loud. They stick in your head because money is uncomfortable. A prospect pushing back on cost feels like a direct challenge to the offer.
Integration objections were quieter. They showed up as practical questions:
- "Does it work with our EMR?"
- "Can it book inside the system?"
- "What happens if the patient gives partial information?"
- "Can it handle routing for different appointment types?"
- "Will staff have to double-enter anything?"
Individually, those felt like normal due diligence.
Aggregated across calls, they were the main story.
That's the part I think a lot of founder-led sales teams miss. The pipeline doesn't just contain deals. It contains buyer truth, but it's usually scattered across call recordings, notes, proposal edits, Slack messages, and whatever you remember while making coffee.
If you're the person taking the calls, you feel close to the market.
Sometimes you're too close.
You remember the spicy objection. You remember the prospect who negotiated hard. You remember the call that went sideways. You remember the weird one.
But the boring repeated questions are often the actual market signal.
For me, the useful thing wasn't that AI wrote a proposal faster, although that did help.
The useful thing was forcing the pipeline to give me a pattern I couldn't hand-wave.
41 calls.
26 objections.
EMR integration first.
Pricing second.
Once I saw that, a bunch of other work became obvious:
- the proposal needed a stronger implementation section
- the sales call needed to address integrations earlier
- the demo needed to show the operational workflow, not just the voice quality
- follow-ups needed to answer "will this fit our clinic?" before restating the value
- call scoring needed to check whether I handled integration clearly
That's where the workflow started feeling less like "AI writes stuff" and more like a second brain for the sales process.
Not in the fluffy sense.
More like: it remembers what I said, compares it to what I've done before, spots repeated patterns, and turns the next step into a draft I can actually use.
I still review everything. I still edit. I still decide what gets sent.
But I don't have to rebuild context from scratch after every call.
That was the big shift.
Most of my leakage wasn't from lack of effort. It was from being the manual bridge between tools that each held one piece of the truth.
The CRM had the stage.
The call recorder had the conversation.
The proposal folder had the precedent.
My head had the judgment.
The system became useful when it could connect those pieces and show me what was actually happening.
I built a plugin around this. DM me if curious.