Kno2gether kno2gether.com ↗ Try Knotie free
Playbook

Claude Builds the Deliverable Before the Call Ends

The video showed it: hang up the sales call, and Claude already knows what to build — because it read the transcript itself. This is the copy-paste version: wire your AI notetaker's MCP into Claude, drop in the post-call prompt that turns 'what they said' into a build spec, and hand that straight into a scaffold step. The deliverable starts itself.

See how Knotie does white-label AI
01

Why this is worth wiringThe dead hour after the call

You finish a sales or scoping call. You hang up. And then the worst part of the job begins: you scroll back through your own notes, try to remember what they actually asked for versus what you think they asked for, and start a blank doc. That gap — between the call ending and the work starting — is where momentum and accuracy both die. The fix is small and durable: your AI notetaker already has a perfect transcript. If Claude can read that transcript directly, it can extract the build spec from what was literally said and start the deliverable while the call is still warm. The key idea: the spec comes from what they said, not from your memory of it. You wire this once and every future call gets the same treatment.

This is taught in Albert Olgaard's 'Start a 1-Person Business with Claude.' We're giving you the connect-and-prompt mechanics as an original, copy-paste build — so you never have to watch over someone's shoulder to reproduce it.
02

The add-a-connector flowConnect your notetaker's MCP to Claude

Claude can reason brilliantly about a transcript — but only if it can reach one. An MCP (Model Context Protocol — Anthropic's open standard for letting an agent call external tools) is the bridge. The course uses Fathom, an AI notetaker that records and transcribes meetings and ships a real Claude connector; the same flow works for any notetaker that exposes an MCP. There are two paths, depending on whether your notetaker is already in Claude's connector directory.

  1. Easy path (directory connector): In Claude, open Settings → Customize → Connectors (the menu label moved from 'Settings' to Customize on recent builds — if you don't see it there, check under Settings directly). Find your notetaker — Fathom ships an official Claude connector — click Connect, and complete the OAuth prompts to authorize your account.
  2. Custom path (paste a URL): If your notetaker isn't in the directory, in the same Customize → Connectors screen click the + (Add custom connector), give it a name, and paste the server's remote MCP URL (always https://… with the correct path). Some servers also want an OAuth login or an API key.
  3. Authorize when prompted. The connection runs from Anthropic's servers to the notetaker's — you're granting Claude read access to your meetings.
  4. Restart Claude. New MCP tools register on launch — if you skip the restart, the tools simply won't show up and you'll think the connector is broken.
  5. Verify: open a new chat and ask 'what tools do you have from <notetaker>?' — you should see meeting/transcript tools listed (e.g. list/search meetings, get transcript, get summary).
Team or organization owners may need to enable a directory connector before individuals can connect it. If 'Connect' is greyed out, that's the likely reason — ask whoever owns the workspace.
03

The tools, namedWhat the connector actually gives Claude

Once connected, Claude gets a set of meeting tools it can call on its own. The exact names depend on which server you use. Fathom's official connector exposes your meeting summaries, transcripts, and action items (it describes the capability rather than publishing tool names). A widely-used community Fathom MCP server (agencyenterprise/fathom-mcp-server) publishes its tools explicitly — handy to know so your prompt can name them:

ToolWhat Claude can do with itWhen it fires
list_meetingsPull recent meetings, filtered by date / team / recorderWhen you say 'my last meeting' and it needs to find which one
search_meetingsFind a meeting by title, host, or attendeeWhen you name the client or call ('the Acme scoping call')
get_transcriptFetch the full word-for-word transcript of a recordingThe core call — this is the source of truth for the spec
get_summaryFetch the AI-generated summary + action itemsA fast first pass; pair it with the transcript for detail
list_teams / list_team_membersSee teams and membershipRarely needed for a solo build; useful in shared workspaces
Don't hardcode tool names you heard in a video. Official Fathom = OAuth directory connector (capabilities: summaries, transcripts, action items). Community server = get_transcript / get_summary etc. at https://www.fathom-mcp-server.com/mcp. Always copy the URL and tool names from the provider's own docs.
04

Copy this, paste it, hang upThe post-call prompt

This is the whole trick in one message. The instant the call ends, open Claude and paste the prompt below. It tells Claude to pull the transcript itself, extract only what was actually said, and turn it into a build spec — not a summary. Keep the framing strict: a spec is decisions and requirements, a summary is vibes.

  • The prompt: Pull the transcript of my last meeting (use my notetaker connector). From the transcript ONLY — not your assumptions — extract exactly what to build. Output: (1) the one-line deliverable, (2) a numbered list of concrete requirements the client stated, each with the quote it came from, (3) explicit constraints (deadline, budget, must-haves, must-NOT-haves), (4) open questions where the call was ambiguous, (5) anything I implied I'd send that isn't a feature. Do not invent requirements. If something wasn't said, put it under open questions.
  • Why 'with the quote it came from': forcing Claude to cite the line keeps it honest. If it can't point to where a requirement was stated, it's a hallucination — and you'll see it instantly.
  • Why 'open questions' is mandatory: the most dangerous output is a confident, complete-looking spec that quietly papered over an ambiguity. Making Claude surface what was unclear turns gaps into your follow-up email instead of a wrong build.
  • Name the meeting if 'last meeting' is wrong: back-to-back calls confuse 'last.' Say 'the call with Acme this afternoon' and Claude will use search_meetings to grab the right one.
The output of this step is a spec document, not a chat you'll lose. Tell Claude to save it to a file (or an artifact) so the next step has something concrete to build from.
05

Where 'extract' becomes 'build'Hand the spec into a build step

A spec sitting in chat is still just notes. The payoff is feeding it straight into a scaffold so the deliverable literally starts existing before you've made a coffee. Keep the two steps separate — extract, then build — so a bad extraction never silently becomes a bad build.

  1. Confirm the spec first: read Claude's extracted requirements, resolve the open questions (a quick reply to the client, or your own decision), and lock it. This 60-second check is the whole reason you forced citations and open-questions.
  2. Then instruct the build: 'Using the spec above, scaffold the first version of the deliverable — <name the artifact: a proposal doc, a landing page, a project plan, a quote, a slide outline>. Follow the requirements exactly; where the spec has an open question, leave a clearly-marked TODO rather than guessing.'
  3. Let Claude produce the actual artifact (a doc, an outline, code, a page) — not a description of one. A client opens a file; they don't open a transcript of your intentions.
  4. Iterate against the spec, not your memory: 'requirement 4 says weekly reporting — the draft only has monthly, fix it.' The spec is now your single source of truth for the whole deliverable.
Two prompts, one flow: transcript → spec (extract), spec → artifact (build). Keeping them distinct means you can re-run the build without re-pulling the call, and audit exactly which requirement produced which part of the deliverable.
06

Don't ship the first thingWhat 'good' looks like — and the gotchas

This workflow is fast, which is exactly why it can be confidently wrong. A 'good' run looks like: every requirement traces to a real quote, the open-questions list is honest (an empty one on a complex call is a red flag, not a win), and the draft deliverable matches the spec line for line. Here's where people get burned.

  1. You forgot to restart Claude. The connector's tools don't appear until you relaunch — the #1 'it's not working' cause. Restart, then re-check the tools list.
  2. OAuth not completed / token expired. If Claude says it can't access meetings, re-run the Connect/authorize step. Directory connectors silently lose auth; reconnect and try again.
  3. The spec is from memory, not the transcript. If Claude starts listing requirements with no quotes, it's filling gaps from training instead of the call. Re-prompt: 'use the transcript tool — quote the line for every requirement or move it to open questions.'
  4. 'Last meeting' grabbed the wrong call. On a busy day, name the meeting explicitly so it searches instead of guessing.
  5. You shipped the draft as-is. The agent extracts and drafts at best-effort. You resolve the open questions and you approve before it reaches the client. Speed is the point; skipping the human check is not.
The reusable shape: connect once → restart → post-call prompt (transcript → cited spec) → confirm + resolve open questions → build prompt (spec → artifact) → you approve. Save that flow and every future call runs it the same way.

Get the next drop

New AI build guides + the occasional bonus template. No spam, unsubscribe anytime.

By submitting you agree to our Privacy Policy & Terms. Unsubscribe anytime.

Frequently asked questions

What is Fathom and why does the course use it?
Fathom is an AI notetaker that records, transcribes, and summarizes your meetings. The reason it matters here is that it ships a real MCP connector for Claude — so Claude can read your call transcripts directly. Albert Olgaard's 'Start a 1-Person Business with Claude' uses Fathom for exactly this, but the workflow is notetaker-agnostic: any notetaker that exposes an MCP works the same way.
How do I connect the notetaker's MCP to Claude?
Open Settings → Customize → Connectors in Claude (the menu shifted from 'Settings' to Customize on recent builds). If your notetaker is in the directory — Fathom is — click Connect and complete the OAuth prompts. If it's not, click + to add a custom connector, give it a name, and paste its remote https://… MCP URL (plus an OAuth login or API key if the server needs one). Then restart Claude so the tools register.
Why do I have to restart Claude after adding a connector?
New MCP tools are registered when Claude launches. If you add a connector and don't relaunch, the tools won't appear and it'll look like the connector failed. Restart Claude, then ask 'what tools do you have from my notetaker?' to confirm they're loaded. This is the single most common 'it's not working' cause.
What exactly should I paste after the call?
A prompt that tells Claude to pull the transcript itself and extract a build spec — not a summary — from the transcript only. Force it to (1) state the one-line deliverable, (2) list concrete requirements with the quote each came from, (3) capture constraints, (4) surface open questions where the call was ambiguous, and (5) note anything you implied you'd send. The 'quote it came from' rule is what keeps Claude from inventing requirements — if it can't cite the line, it's a hallucination.
Can I trust the spec it builds — won't it hallucinate requirements?
Treat it as a fast, best-effort first pass, not gospel. The guardrails are baked into the prompt: every requirement must cite a real quote (so fabrications are obvious), and anything ambiguous goes to an 'open questions' list instead of being guessed. You resolve the open questions and approve the spec before anything is built or sent to the client. The spec must come from what was said, not from Claude's memory.
Sources · Concept credit: Albert Olgaard, 'Start a 1-Person Business with Claude' (course) — this guide is an original rebuild of the connect-and-prompt technique from the primary docs below, not a transcript. No income/earnings figures are stated. · Fathom connector for Claude — official integration page · Fathom + Claude — what's possible (Fathom Help Center) · Community Fathom MCP server (publishes exact tool names: get_transcript, get_summary, list_meetings, search_meetings) — GitHub · Get started with custom connectors using remote MCP — Claude Help Center (menu: Customize → Connectors) · Build custom connectors via remote MCP servers — Claude Help Center · Model Context Protocol — Anthropic (the open standard MCP connectors are built on)

Claude can build YOUR deliverable from a call. Knotie lets you sell that capability to clients under your own brand.

This playbook gets your own Claude reading transcripts and starting the work. The next step is turning it into something clients pay for: standing the same agent capability up as a product they buy — under your brand, your domain, with billing that meters their usage so you keep the margin. That's exactly what Knotie is built for: resell voice and chat agents plus automations across providers, with a customer portal and credit billing baked in, no code. You productize the after-the-call magic; Knotie handles the white-label plumbing.

See how Knotie does white-label AI