Build a deck with an AI agent

An agent that writes slides blind makes slides that overflow, crowd and clash. Kadal Deck gives an agent what you have: the reference for every component, edits that touch one slide at a time, the linter, and pictures of the slides it made. In this guide you have an agent draft a talk, review it and publish it. Pick one of three places for the agent to run:

Where	You need	Best for
Claude Code, with the plugin	Claude Code, Node 20.19+	a deck in a folder on your machine or in a repo
Any MCP client	Claude Desktop, Cursor, VS Code or another MCP client, Node	the same, from the app you already use
The builder on deck.kadal.cc	a deck.kadal.cc account and an API key from an AI provider	writing in the browser, with nothing to install

Claude Code

1. Install the plugin

In Claude Code:

/plugin marketplace add kadalcc/deck
/plugin install kadal-deck@kadal-deck

The plugin brings two things: the kadal-deck skill (the workflow, the file format, every component and a design guide for talks) and the local MCP server (kadal-deck mcp, 24 tools). Restart Claude Code if it asks.

2. Ask for the talk

Open Claude Code in the folder where the deck should go and describe the talk the way you would to a colleague. Say who is listening, how long you have, and the one thing they should remember:

Make a Kadal Deck talk in ./tide-talk: "Reading the tide", 15 minutes, for a fishing
co-operative's annual meeting. Most of the room has never read a tide table. By the end they
should be able to read one. Include a poll near the start about how they check the tide today,
and a slide with this week's high-water times for Chennai: Mon 06:12, Tue 06:58, Wed 07:41.

The more of your own material you give it (notes, an outline, numbers, the order you want), the less it invents.

3. Let it work, and read along

The skill tells the agent to work in a loop. You’ll see the tool calls go by:

1. deck_create scaffolds tide-talk/ from the starter and installs its packages.
2. deck_reference looks up each component before it uses one (<Poll>, <Clicks>, a layout).
3. slide_update, slide_add and notes_set write the slides. Each changes only that slide’s lines in deck.mdx and lints it on the spot: “Updated slide 1 (Why the tide matters); the deck has 8 slides. No problems on this slide. Look at it with slide_render.”
4. deck_check runs the linter over the whole deck.
5. slide_render returns pictures of the slides, every click revealed. The agent looks at each one for text that overflows, crowding, tiny type and poor contrast, fixes what it sees, and renders again.

slide_render needs Playwright and Chromium in the deck. If the agent reports that they’re missing, let it run (or run yourself), in the deck’s folder:

npmpnpmyarnbun

npm i -D playwright && npx playwright install chromium

pnpm add -D playwright && pnpm dlx playwright install chromium

yarn add -D playwright && yarn dlx playwright install chromium

bun add -D playwright && bunx playwright install chromium

4. Look at it yourself

Ask “open a preview”: deck_preview starts the dev server and gives you the deck, presenter and audience addresses. Or run npm run devpnpm devyarn devbun run dev in tide-talk/. Edits the agent makes from now on appear live. Ask for changes in plain words (“slide 4 is too dense, split it”, “use the ocean theme”, “add speaker notes to every slide”), or edit deck.mdx yourself and ask it to check your work.

For a second opinion on a deck, ask for a review: the server’s review_deck prompt checks and renders every slide and reports the problems by slide, with the three changes that would help most.

5. Publish

Publishing needs you signed in, once, on this machine. The agent never signs in for you:

npmpnpmyarnbun

npx kadal-deck login

pnpm exec kadal-deck login

yarn kadal-deck login

bunx kadal-deck login

Then ask “publish it”. deck_publish builds the deck and uploads it, and the agent replies with the address, https://decks.kadal.cc/@<you>/tide-talk/, with a live room for the poll. See The hosted service for visibility, passcodes and versions.

Any other MCP client

The plugin is the skill plus the server. In another client, add the server yourself and point it at the folder your decks live in. In Claude Desktop (claude_desktop_config.json) or Cursor (.cursor/mcp.json):

{
  "mcpServers": {
    "kadal-deck": {
      "command": "npx",
      "args": ["-y", "@kadal/deck", "mcp", "--dir", "/Users/you/talks"]
    }
  }
}

In VS Code, install the Kadal Deck extension: it offers the server for the deck you have open to Copilot’s agent mode and other agents (VS Code 1.101 or later), with no configuration. AI agents and MCP has the .vscode/mcp.json form for other setups.

The server reads and writes only inside --dir (or the folder it starts in). Leave it that way: it is your guarantee that an agent working on a talk can’t touch anything else. --allow-outside lifts it, for a deck whose src: includes live elsewhere.

Without the skill, the server still describes its tools and the workflow to the agent, and serves the skill’s guides as resources (kadal-deck://guide/design-guide, …/authoring). To start a deck the same way the plugin does, use the server’s draft_deck prompt, which takes the topic, an outline, the audience and the length. For agents that read Agent Skills, add the skill too:

npmpnpmyarnbun

npx skills add kadalcc/deck

pnpm dlx skills add kadalcc/deck

yarn dlx skills add kadalcc/deck

bunx skills add kadalcc/deck

The builder on deck.kadal.cc

The builder writes a deck in the browser, beside a live preview, and its assistant edits the draft with you. It runs on your own key from an AI provider: you pay the provider for what the model uses, and the key never reaches the browser.

1. Add an AI key

Open the dashboard’s AI keys page, deck.kadal.cc/app/ai, and add a key from OpenAI, Anthropic, Google, OpenRouter or any OpenAI-compatible API (with its base URL). Kadal checks the key with the provider before saving it, encrypts it, and from then on shows only its last four characters. Only an owner or admin of the workspace can add keys; everyone in the workspace can use them.

2. Start a draft

Open deck.kadal.cc/app/build and create a draft: the starter (a short tour of layouts, clicks, code steps and a poll), a blank deck, or a copy of a deck you published from the builder. The Free and Starter plans keep one draft at a time; Pro and Team have no limit.

3. Tell the assistant about the talk

Open the assistant panel. Its Deck settings tab holds what the assistant should know: what the talk is about, its purpose, who is listening and their level, the length, the tone, the theme, light or dark, how much interaction, code and maths, and anything else in your own words. Pick a model, and how long it thinks before each step: Quick (seconds, right for most edits), Balanced or Deep (a minute or more per step).

4. Ask for slides

In the Chat tab, ask as you would in Claude Code, or paste your notes:

Turn these notes into a 15-minute talk with a poll after the intro. Keep my wording where you can.

Each change the assistant makes lands in the editor as it happens, recompiles the preview, and is saved as a revision marked Assistant, so you can undo any of them. It compiles and lints the deck after each batch of edits and fixes what that finds, including text that overflows a slide, and it shows you the slide it is working on. Comments you pin on slides are part of the conversation: ask it to “work through the open comments” and it answers and resolves them.

5. Publish

Publish in the builder makes the draft an ordinary published deck at https://decks.kadal.cc/@<you>/<slug>/, with its room, analytics and version history, exactly as kadal-deck publish would.

After you publish

• Manage decks from your AI app. The remote MCP server at https://deck.kadal.cc/mcp lists your published decks, changes visibility and passcodes, rolls back versions, makes share links and reads a live room’s questions while you talk.
• Copilot while you present. In the presenter view of a hosted deck, the Copilot tab takes requests like “go to the results slide” or “circle the total” and runs them as the deck’s own commands. It uses the same AI key, and it can’t change the deck.

Next

• AI agents and MCP: every tool, resource and prompt, and the permissions of the remote server.
• Your first deck in 5 minutes, to know what the agent is writing.
• Use Kadal Deck in VS Code.