"Implement What We Agreed in the Meeting": Spec-to-Code with SuperIntern MCP and Claude Code
Think about what happens right after a spec review ends.
You collect the decisions from your notes, scroll back through Slack threads, reconstruct the reasoning, and then paste it all into your AI coding agent to explain the spec from scratch. Miss a detail and the AI fills the gap with a plausible guess, which comes back to you in review as "that's not what we agreed." The meeting lives in SuperIntern, the code lives in your repo, and the bridge between them has always been copy-paste and memory.
In this article, we connect SuperIntern's MCP to Claude Code so that "implement what we decided in the meeting" works as a single prompt, inside your editor, with real prompt examples you can copy.
⚠️ This article was independently compiled based on publicly available information and user feedback as of August 2026.
Table of contents
- What we're building: before / after
- How it works: three roles
- Setup
- Demo 1: Start implementing right after the meeting
- Demo 2: Verify a decision down to the exact words
- Demo 3: Scaffold the code before the meeting ends
- Tips and caveats
- Going further: the same pattern, other workflows
- FAQ
What we're building: before / after
Before: after each spec review, you re-assemble the spec from notes and Slack, paste it into your coding agent, and hope you did not leave anything out. Any gap becomes a guess, and any guess becomes rework.
After: you tell Claude Code "implement what was decided in today's spec review." It fetches the meeting summary and transcript itself, confirms the decisions, and starts implementing. No more spec telephone, and every change traces back to the meeting that motivated it.
As background: SuperIntern is a botless desktop app (no bot joins your calls) that automatically keeps transcripts and AI meeting summaries. Your spec reviews and design discussions are already piling up as data. The only missing piece is turning them into code, and that is exactly the part you can now hand to your agent.
How it works: three roles
Three actors make this workflow tick.
| Role | Actor | What it does |
|---|---|---|
| Provide meeting data | SuperIntern MCP | Serves transcripts, live transcripts, AI summaries, and meeting notes, read-only |
| Reason and implement | Claude Code (your AI coding agent) | Reads specs and decisions from meeting data, then designs, codes, and tests |
| Receive the action | Your repository | All changes land in your local codebase; nothing is ever written back to meeting data |
MCP (Model Context Protocol) is an open standard for connecting AI agents to external tools safely. SuperIntern's MCP serves your meeting data to AI clients read-only. The code is written by Claude Code, not by SuperIntern, and the only thing that changes is your repository. Your meeting data can never be modified through MCP, and each user can only access meetings they can already view in SuperIntern. You can try this without any "the AI broke my meeting notes" anxiety.
Setup
There is exactly one connection to set up. Run this in your terminal:
claude mcp add --transport http superintern https://mcp.app.super-intern.com/mcp
Then run /mcp inside Claude Code, pick superintern, and authenticate. A browser window opens; sign in with your SuperIntern account and approve. No API keys to create or manage.
Plan requirements on the SuperIntern side (Plus or higher for personal workspaces, admin enablement for Enterprise) and setup steps for other coding agents such as Cursor and Codex are covered in our MCP setup guide. The prompts in this article work nearly unchanged in any MCP-capable coding agent.
Not sure the connection works? Ask this first:
List my three most recent SuperIntern meetings
If titles and dates come back, you are ready.
Demo 1: Start implementing right after the meeting
The most frequent use is the moment a spec review or design meeting ends. The key habit: make the agent confirm the decisions before writing code. It prevents the AI from starting on assumptions.
Fetch the AI summary of today's "Payments spec review" meeting and
implement the webhook retry logic exactly as decided there.
Before you start, show me the relevant decisions as a bullet list
Claude Code fetches the summary and answers first with something like this:
I found 3 decisions relevant to this implementation:\
- Retries use exponential backoff, max 5 attempts, capped at 24 hours\
- Events that fail 5 times are stored in a failures table and surfaced on the dashboard\
- The manual resend API is deferred to phase 2 (out of scope here)
Proceeding on this basis. Starting with the failures table schema.
From there it plans and codes like any Claude Code session. The difference is that the plan is grounded in the meeting record itself, not in whatever you managed to paste. Scope lines like "manual resend is phase 2" come straight from the meeting, so you also stop getting features you did not ask for.
Demo 2: Verify a decision down to the exact words
Mid-implementation, the moment always comes: "wait, which option did we actually settle on?" Until now that meant asking in Slack or scanning the minutes by eye. Now you check from the editor:
For this job's concurrency control, check how Thursday's "Architecture sync"
concluded. Look at the transcript passage itself, not just the summary.
Then review whether my current implementation matches that conclusion
Pointing the agent at the transcript, not only the summary, is the trick. Summaries compress; conditions and nuance survive better at the level of what was actually said. Claude Code quotes the passage and answers like this:
I checked the relevant passage in the Architecture sync transcript.
The conclusion was: "we prevent duplicate job runs with a database advisory lock; Redis is not in scope this round."
Your current implementation assumes a Redis lock, which contradicts that conclusion.
Here is a proposed fix that switches to the advisory lock approach.
Building on "I'm pretty sure we said..." and finding out in review is the most expensive kind of rework. One verification prompt makes it disappear.
Demo 3: Scaffold the code before the meeting ends
SuperIntern MCP includes a tool that fetches the live transcript of a meeting still in progress, with incremental updates. That means you do not have to wait for the meeting to end to start building.
Fetch the live transcript of the "Schema design" meeting happening now and
scaffold the migration and type definitions for the tables we've agreed on so far.
Leave TODO comments in the code for anything still under discussion
While you sit in the meeting, Claude Code turns "agreed so far" into a scaffold on your machine. Open points stay as TODOs, so when the meeting closes you start from "the settled parts exist, the contested parts are marked." Because SuperIntern is botless, the meeting itself needs zero preparation: you run it as usual, and the transcript accumulates automatically.
Tips and caveats
Name the meeting and project explicitly. "Today's 'Payments spec review'" beats "today's meeting" at reliably pinning down the right session, and it matters more the busier your calendar is.
Keep the decision-confirmation step at first. One line, "show me the decisions before you start," lets you catch misreadings before any code exists. Once you trust how the agent reads your team's minutes, drop it.
Put a grounding rule in your project's CLAUDE.md. Add "when referencing specs or decisions, verify them against the relevant meeting via SuperIntern MCP before writing code" to your project memory, and grounded implementation becomes the default without repeating it in every prompt.
Improve proper nouns on the SuperIntern side. The more accurately feature names and teammate names are transcribed, the better the spec extraction. Register frequent terms in SuperIntern's custom dictionary.
Meeting content is data, not instructions. Transcripts contain all kinds of utterances, so SuperIntern MCP responses carry an explicit note for AI clients to treat meeting content as data and never execute it as instructions. Small talk in a meeting does not turn into code.
Writes happen only in your repository. Nothing in SuperIntern changes through MCP. If you dislike the result, git revert and move on; the cost of a failed attempt stays low.
Going further: the same pattern, other workflows
"SuperIntern MCP provides the data, Claude Code reasons, your repository receives the result" extends beyond implementation.
- Chain ticketing into implementation: connect Linear MCP too and "file the action items from the meeting in Linear, then start on the first one" works end to end. The ticketing side is covered in our Linear article
- Quote decisions in PR descriptions: ask "add the meeting decisions behind this change to the PR description" and reviewers can trace the why all the way back to the meeting
- Onboard new engineers: "explain how this module ended up with this design, using the meetings where it was discussed" attaches meeting context to code reading
We will keep exploring combinations like these in this series, always with real prompts.
FAQ
Q. Is SuperIntern MCP available on the free plan?
A. No. Personal workspaces need the Plus plan or higher. Team plan workspaces can use it as is, and Enterprise workspaces require an admin to turn on "MCP access" in workspace settings.
Q. Does this work with coding agents other than Claude Code?
A. Yes. SuperIntern MCP works from Cursor, Codex, and other MCP-capable clients using the same connection URL, and the prompts in this article carry over nearly unchanged. See the MCP setup guide for per-client steps.
Q. Can the AI modify my meeting notes or transcripts?
A. No. Every SuperIntern MCP tool is read-only; no create, update, or delete operations exist. Writes only happen in your repository.
Q. Can it read my teammates' meetings?
A. Only meetings you can already view in SuperIntern are accessible. Meetings in restricted projects stay invisible to the Claude Code of anyone without access.
Q. What about very long meetings?
A. Long transcripts are served in pages, so Claude Code can work through a multi-hour meeting section by section.
Q. Could something said in a meeting get implemented by accident?
A. No. Implementation always starts from the prompt you type into Claude Code; meeting data is never executed on its own. Add the decision-confirmation step from the tips above and a human checks the reading before any code is written.
Q. How do I disconnect?
A. Run claude mcp remove superintern in Claude Code and the connection is no longer used. In Enterprise workspaces, an admin turning off "MCP access" also revokes all previously granted connections at once.
SuperIntern already handles "keeping the record" of what your team decides. The next step is making "turning it into code" just as automatic.