AI-Assisted Call-Note Drafting Workflow

TL;DR

I built a custom AI assistant (a Gemini Gem) that converts an AI-generated call summary into a concise, consistently formatted CRM call note — a Subject line plus a 1–3 sentence Call Summary. The rep stays in the loop: the AI produces a draft, the rep reviews and edits it, then pastes it into the CRM. It's designed to capture every relevant call detail consistently and raise note quality — without removing human judgment.

How this started

The team was recently told to use the Five9 Agent Assist transcript on every call and shorten it into a call note in NetSuite. The entire guidance was essentially one sentence: "you can use AI." No template, no format, no guardrails. So I built my own — a Gem with a strict output format and a set of behavioral rules, so my own notes would be consistent, scannable, and fast to produce instead of ad hoc every time.

The problem

After every call, support reps have to write a case note in the CRM. The raw material is an AI-generated call summary that's verbose, uses generic labels ("Agent," "Customer"), mixes tenses, and buries the actual outcome.

The real cost wasn't time — it was completeness.

Writing notes under pressure from a messy source meant relevant details got dropped: the reason for the call, the action taken, the outcome, a ticket number, a follow-up. The workflow's job is to make sure nothing important gets lost — turning a verbose, inconsistent source into a clean, scannable note that captures the full picture, every time. That's exactly the kind of task AI should handle without taking the rep out of the loop.

The workflow

Key point: the AI never writes directly to the CRM. It produces a draft; a human reviews, edits, and posts it. The human is the gatekeeper for accuracy, tone, and judgment — the AI just removes the repetitive formatting work.

The prompt design

The workflow lives or dies on the prompt. Here's the design (a generalized version of what I run), with the interesting prompt-engineering choices called out below.

You are an expert internal communications and operations assistant
specializing in CRM call-note documentation. Your sole task is to
transform a call transcript summary into clean, highly scannable
CRM call notes.

1. OUTPUT FORMAT
Your output must contain ONLY these two fields, with no
conversational filler before or after:

Subject:
[Customer First Name] called for [very short reason]

Call Summary:
[1–3 concise sentences focusing strictly on the call result,
incorporating key details needed for future reference.]

2. CORE RULES
- Result Focus: Summarize the outcome described in the
  "Result" section of the input only.
- Identity Substitution: NEVER use the word "Agent".
  Always use "Janackeh" instead.
- Customer Focus: NEVER use the generic word "Customer" if the
  customer's name is available. Use the customer's first name.
- Ticket Numbers: If a ticket number appears anywhere in the
  text, include it in the summary.
- Tense & Style: Write exclusively in the past tense. No numbered
  lists, bullet points, or section headers inside the Call Summary.
  Combine into a brief, fluid, professional summary.
- Strict Brevity: Exclude filler, greetings, and historical steps.
  Focus on what was ultimately achieved, given, or instructed.

3. SUBJECT EXAMPLES
- Alex called for order status
- Jordan called about credit card charges

Why these prompt choices matter

• Identity substitution — "never say 'Agent', use the rep's name." Forces a personal, accountable voice instead of a generic call-center tone.
• Customer-focus rule — replaces the dehumanizing "Customer did X" with the person's actual name.
• Result-only focus (v2) — when the note guideline changed to "summarize the result, not the whole call," I updated the prompt the same week to restrict the summary to the Result section. That adaptability is the point: the prompt is a versioned, maintainable asset, not a one-off.
• Strict output schema — two fields, no filler, so the output is paste-ready and consistent each time.
• Ticket-number carry-through — a small rule that prevents a common documentation gap.

What I learned about prompting

The biggest lesson: let the AI prompt itself. Instead of hand-writing every rule from scratch, I give the model the input, the goal, and the constraints, and let it produce an expert-level prompt — then I refine. That's how this workflow's prompt was shaped: I described what I wanted (a clean Subject + Call Summary, past tense, no filler, the customer's first name, the ticket number, no "Agent"), let the AI draft the system prompt, and tightened it from there. It's faster, and the result is usually sharper than what I'd write solo. The skill isn't writing the perfect prompt — it's knowing what to constrain and then editing the draft like a senior reviewer.

Before / after

All names, dollar amounts, order numbers, and ticket numbers in the examples are fake.

How the human stays in the loop

1. The AI generates a draft — never a final.
2. The rep reviews the draft against what actually happened on the call (the AI summary can be wrong or incomplete).
3. The rep edits — fixes names, adds anything the transcript missed, adjusts tone.
4. The rep posts the note to the CRM.

When the AI gets it wrong (and how I handle it)

The workflow isn't perfect — and that's exactly why the human stays in the loop. Sometimes the AI summary gets a detail wrong (the caller's name, the actual nature of the call), or the summarized transcript doesn't populate at all. When that happens, I don't fight the broken summary: I paste the full raw transcript straight into the Gem, and the prompt still produces a clean, correctly-formatted note. The fallback is built into the workflow, not bolted on — which is why the prompt's robustness matters more than any single "perfect" output.

This is the part I'd want a skeptical CX/Ops leader to see: the tool isn't trusted blindly, and it degrades gracefully when the upstream AI summary fails.

This is the model I believe in for AI in support: AI handles the repetitive transformation (search, summarize, format, verify) so the human stays focused on judgment, empathy, and complex resolution.

Metrics to track

Outcomes are not yet formally measured — these are the metrics I'm tracking to validate the workflow.

• Documentation completeness (primary) — whether every relevant detail is captured: reason for call, action taken, outcome, ticket number, follow-ups. This is the real win — before, details got dropped under pressure; now they don't.
• Note consistency — does every note follow the Subject + Call Summary schema.
• QA pass rate on documentation — fewer notes flagged for missing ticket numbers, wrong tense, or missing outcome.
• Adoption — how often I use the draft vs. rewrite from scratch.
• After-call documentation time (secondary) — not the goal, but a useful efficiency signal to watch.

Edge cases & future state

The hard case: multi-issue, multi-order calls. When a single call covers several issues across several orders, the workflow's single-note output doesn't fit cleanly — and right now the team is told we don't have to use Agent Assist for those calls at all.

Planned feature: split into 2+ notes. For the future state, I want the workflow to detect a multi-issue / multi-order call and separate the output into two or more structured notes — one per issue or order — each with its own Subject and Call Summary. That turns today's edge case into a handled one, and it's the next version of the prompt I'm designing.

Why this matters (the bigger picture)

AI in support should do all the time-consuming, repetitive tasks so humans can remain the warm human element in the relationship.

This isn't "a cool prompt." It's a small example of a repeatable pattern: take a repetitive, judgment-light documentation task, let AI draft it, keep the human as the reviewer. That pattern generalizes — to email drafting, mispick verification, knowledge-base article drafting, and coaching summaries — which is exactly the lane I'm building toward: AI-enabled support operations and CX workflow design.

Tech stack