Skip to main content

How to Use Felo Slides with Claude Code and AI Agents

· 12 min read
Felo Search Tips Buddy
Felo Search Tips Buddy
Committed to answers at your fingertips

Build AI-powered slides from the terminal using Felo Slides with Claude Code, OpenClaw, and the felo-slides npm package. A developer's guide to programmatic slide generation.

$ npx felo-slides "Explain Kubernetes pod scheduling in 8 slides"
✓ Analyzing topic...
✓ Generating outline (8 slides)...
✓ Creating slide content...
✓ Building presentation...
✔ Done → kubernetes-pod-scheduling.felo

That's it. No browser. No drag-and-drop. No template picker. You typed one command, and eight slides appeared.

If you've ever sat through a 40-minute meeting that should have been a slide deck, you already know why we built Felo Slides. But this post isn't about the web app — it's about what happens when you give developers an API and tell them to automate everything.

Here's how to use Felo Slides with Claude Code, OpenClaw agents, and your own scripts to generate AI slides without ever leaving the terminal.

[IMG: Terminal screenshot showing the felo-slides CLI generating a presentation from a single prompt, with the output file highlighted]

What Is Felo Slides (for Developers)?​

Felo Slides is an AI presentation engine. Most people know it as a web app at slides.felo.ai. Under the hood, it's also:

  • felo-slides npm package — a CLI and library for generating slides programmatically
  • Claude Code Skill — a native skill that lets Claude Code create presentations inline
  • OpenClaw Skill — same idea, wired into the OpenClaw agent framework
  • REST API — HTTP endpoints for slide generation, topic analysis, and template rendering

The web app is the polished frontend. The developer tools are the engine. You can mix and match: use the CLI for quick local generation, the API for server-side automation, or the Claude Code skill for conversational slide building.

When to use which:

Use CaseTool
Quick slides from terminalfelo-slides CLI
Conversational generation in your editorClaude Code Skill
Agent-driven workflowsOpenClaw Skill
Backend / CI / batch jobsFelo Slides API

Installation and Setup​

Prerequisites​

Install the npm Package​

npm install -g felo-slides

Or use it without installing:

npx felo-slides "Your presentation topic here"

Authenticate​

Set your API key as an environment variable:

export FELO_SLIDES_API_KEY=fsk_your_api_key_here

Or create a .felo-slides.json in your project root:

{
  "apiKey": "fsk_your_api_key_here",
  "defaultOutput": "./presentations",
  "template": "developer-dark"
}

Verify It Works​

$ felo-slides --version
felo-slides 2.4.0

$ felo-slides --check
✓ API key valid
✓ Rate limit: 47/50 requests remaining
✓ Templates loaded: 12

[IMG: Side-by-side comparison of terminal output showing successful setup vs. common authentication errors]

Using Felo Slides with Claude Code​

This is where things get interesting. The Claude Code Skill turns Claude's editor into a slide factory. Instead of writing prompts and copying output, Claude generates, edits, and exports presentations directly.

Install the Claude Code Skill​

# In your Claude Code project directory
claude skill add felo-slides

This registers the Felo Slides skill with Claude Code. Claude now knows it can create presentations, and it has access to the full felo-slides API surface.

Basic Usage in Claude Code​

Once installed, just ask Claude naturally:

> Create a 10-slide deck about our Q3 engineering roadmap.
  Include sections on: platform migration, hiring plan,
  and infrastructure budget.

Claude will:

  1. Draft an outline and confirm the structure with you
  2. Generate slide content using the Felo Slides API
  3. Save the .felo file to your project directory
  4. Offer to iterate on specific slides

No context switching. No copy-paste. The slides live in your repo alongside your code.

Advanced: Custom Templates in Claude Code​

You can define project-specific slide templates that Claude will use automatically:

mkdir -p .felo/templates

Create .felo/templates/engineering.json:

{
  "name": "Engineering Update",
  "theme": "dark",
  "accent": "#6366f1",
  "fonts": {
    "heading": "JetBrains Mono",
    "body": "Inter"
  },
  "layout": {
    "titleSlide": "code-hero",
    "contentSlide": "split-left",
    "closingSlide": "cta-minimal"
  }
}

Then in Claude Code:

> Make a deck about the auth service migration.
  Use the engineering template.

Claude picks up the template automatically and applies it to every generated slide.

[IMG: Claude Code editor showing a conversation where the user asks for a slide deck, Claude generates an outline, and the resulting .felo file appears in the file tree]

Editing Slides Conversationally​

The real power of the Claude Code integration is iterative editing:

> Slide 3 is too dense. Split it into two slides.
  Move the architecture diagram to slide 4.

> Add speaker notes to slides 5-7. Keep them under
  50 words each.

> Change the accent color to our brand green (#10b981)
  and add our logo to the title slide.

Each edit is an API call under the hood, but you never see the HTTP request. Claude handles the plumbing.

Using Felo Slides with OpenClaw​

OpenClaw takes the agent approach further. The Felo Slides OpenClaw Skill lets AI agents generate slides as part of larger workflows — not just in response to direct commands.

Setup​

openclaw skill install felo-slides

Configure in your OpenClaw workspace:

# openclaw.yaml
skills:
  felo-slides:
    apiKey: "${FELO_SLIDES_API_KEY}"
    defaultTemplate: "professional"
    outputDir: "./output/slides"

Agent-Driven Slide Generation​

With OpenClaw, you can trigger slide generation from agent workflows:

User: We just closed the Acme deal. Prepare a kickoff
      deck for the eng team. Use the project brief from
      Notion and the timeline from Linear.

Agent: [reads Notion brief]
       [fetches Linear timeline]
       [generates 12-slide kickoff deck via felo-slides]
       [saves to output/slides/acme-kickoff.felo]
       "Done. Created a 12-slide deck covering scope,
        timeline, team assignments, and milestones.
        Want me to send it to #eng-general?"

The agent pulled context from two external tools, structured it into a presentation, and generated the slides — all in one turn.

[IMG: Diagram showing the OpenClaw agent workflow: user request → context gathering (Notion, Linear) → felo-slides API → output file → delivery]

Command-Line Examples​

Let's look at the CLI in more detail. These examples cover the most common developer workflows.

Generate from a Topic​

felo-slides "Microservices vs monoliths: a pragmatic guide" --slides 12

Generate from a Markdown File​

felo-slides --from ./meeting-notes.md --template "standup"

The CLI parses your markdown, detects headings and bullet points, and maps them to slides automatically.

Generate from a URL​

felo-slides --from-url https://github.com/org/repo/blob/main/README.md

Useful for turning documentation, blog posts, or RFCs into presentations.

Batch Generation​

# Generate slides for multiple topics
felo-slides batch --file topics.txt --output ./deck-batch/

Where topics.txt contains one topic per line:

Q4 OKR Review
New Hire Onboarding: Backend
Incident Postmortem: 2026-05-12 Outage
Architecture Decision Record: Event Sourcing

Export Formats​

# Export to PDF
felo-slides export ./output.felo --format pdf

# Export to PPTX
felo-slides export ./output.felo --format pptx

# Export to images (one PNG per slide)
felo-slides export ./output.felo --format png --dpi 300

CI/CD Integration​

# .github/workflows/weekly-deck.yml
name: Generate Weekly Update Deck
on:
  schedule:
    - cron: '0 9 * * 1'  # Every Monday 9 AM

jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npx felo-slides "Weekly engineering update for ${{ github.run_id }}" --template weekly --output ./decks/
      - uses: actions/upload-artifact@v4
        with:
          name: weekly-deck
          path: ./decks/

[IMG: GitHub Actions run log showing the felo-slides step completing successfully, with the generated deck listed under Artifacts]

Automation Workflow Examples​

Here are three real workflows where Felo Slides saves significant time.

1. Pre-Meeting Prep Bot​

A Slack bot that generates a starter deck before every recurring meeting:

import { FeloSlides } from 'felo-slides';
import { getMeetingContext } from './calendar-integration';

const slides = new FeloSlides({ apiKey: process.env.FELO_SLIDES_API_KEY });

export async function prepareMeetingDeck(meetingId: string) {
  const context = await getMeetingContext(meetingId);

  const deck = await slides.generate({
    topic: context.title,
    slides: 8,
    context: [
      `Attendees: ${context.attendees.join(', ')}`,
      `Previous action items: ${context.lastActions.join('; ')}`,
      `Agenda: ${context.agenda.join(', ')}`,
    ],
    template: 'standup',
  });

  await slides.export(deck.id, { format: 'pdf' });
  await postToSlack(context.channel, {
    text: `📊 Starter deck for ${context.title}`,
    files: [{ file: deck.exportPath, filename: `${context.title}.pdf` }],
  });
}

2. Documentation → Presentation Pipeline​

Automatically convert new RFCs or design docs into presentation drafts:

#!/bin/bash
# hooks/post-commit-slides.sh

# Detect new .md files in /docs/rfcs
CHANGED_FILES=$(git diff --name-only HEAD~1 HEAD -- 'docs/rfcs/*.md')

for file in $CHANGED_FILES; do
  TITLE=$(head -1 "$file" | sed 's/^# //')
  OUTPUT="./presentations/$(basename "$file" .md).felo"

  npx felo-slides --from "$file" --template "rfc" --output "$OUTPUT"

  echo "Generated slides for: $TITLE → $OUTPUT"
done

Wire this up as a git hook or CI step, and every new RFC gets a companion slide deck automatically.

3. Multi-Format Content Repurposing​

Turn one piece of content into a blog post, a slide deck, and a social thread:

import { FeloSlides } from 'felo-slides';
import { generateBlog } from './blog-generator';
import { generateSocialThread } from './social-generator';

async function repurposeContent(sourceUrl: string) {
  // Fetch and analyze source content
  const content = await fetchAndParse(sourceUrl);

  // Generate all three formats in parallel
  const [blog, deck, thread] = await Promise.all([
    generateBlog(content, { words: 2000 }),
    new FeloSlides().generate({
      topic: content.title,
      slides: 10,
      context: content.summary,
    }),
    generateSocialThread(content, { posts: 8 }),
  ]);

  return { blog, deck, thread };
}

One source, three outputs. The slide deck isn't an afterthought — it's generated with the same content intelligence as the blog post.

[IMG: Flowchart showing one source content branching into three outputs: blog post, slide deck, and social media thread]

API Reference​

For teams building custom integrations, the Felo Slides API exposes three core endpoints.

Authentication​

All requests require an API key in the header:

Authorization: Bearer fsk_your_api_key_here

POST /v1/slides/generate​

Generate a new presentation.

curl -X POST https://api.slides.felo.ai/v1/slides/generate \
  -H "Authorization: Bearer fsk_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "Introduction to WebAssembly",
    "slideCount": 10,
    "template": "developer-dark",
    "context": [
      "Audience: senior backend engineers",
      "Focus on practical use cases, not theory",
      "Include performance comparison with Docker"
    ],
    "language": "en"
  }'

Response:

{
  "id": "deck_abc123",
  "status": "processing",
  "estimatedSeconds": 15,
  "slides": 10,
  "pollUrl": "/v1/slides/deck_abc123"
}

GET /v1/slides/{id}​

Check status and retrieve a completed deck.

curl https://api.slides.felo.ai/v1/slides/deck_abc123 \
  -H "Authorization: Bearer fsk_your_api_key_here"

Response (when complete):

{
  "id": "deck_abc123",
  "status": "complete",
  "slides": [
    {
      "number": 1,
      "title": "What Is WebAssembly?",
      "content": "...",
      "notes": "..."
    }
  ],
  "downloadUrls": {
    "felo": "https://api.slides.felo.ai/v1/slides/deck_abc123/download?felo",
    "pdf": "https://api.slides.felo.ai/v1/slides/deck_abc123/download?pdf",
    "pptx": "https://api.slides.felo.ai/v1/slides/deck_abc123/download?pptx"
  }
}

POST /v1/slides/{id}/edit​

Modify an existing deck programmatically.

curl -X POST https://api.slides.felo.ai/v1/slides/deck_abc123/edit \
  -H "Authorization: Bearer fsk_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "actions": [
      { "type": "update", "slide": 3, "title": "WASM vs Containers: Benchmarks" },
      { "type": "insert", "after": 5, "title": "Live Demo", "content": "..." },
      { "type": "delete", "slide": 8 }
    ]
  }'

Rate Limits​

  • Free tier: 50 requests/day, 5 requests/minute
  • Pro tier: 500 requests/day, 30 requests/minute
  • Enterprise: custom limits

The felo-slides CLI and all SDKs handle rate limiting automatically with exponential backoff.

[IMG: API documentation screenshot showing the three endpoints with request/response examples]

FAQ​

Can I use Felo Slides offline?​

The generation step requires an API call (the AI model runs server-side). But you can export decks to PDF or PPTX and work with them locally after that. The CLI caches your last 10 generated decks for offline viewing.

How do I handle sensitive content?​

All API requests are encrypted in transit (TLS 1.3) and at rest. Slide content is not used for model training. For enterprise deployments with data residency requirements, contact us about on-premise options.

Can I use my own templates?​

Yes. The npm package and API both support custom templates. Define your template as a JSON file (see the Claude Code section above), then reference it by name or path:

felo-slides "Topic here" --template ./my-template.json

What's the output format?​

Generated decks are stored as .felo files (a structured JSON format). You can export to PDF, PPTX, PNG, or HTML. The .felo format is editable — you can modify it programmatically or re-import it for further AI edits.

Does the Claude Code skill work with Claude CLI or only the desktop app?​

Both. The skill works with claude in the terminal and with the Claude desktop app. Installation is the same either way.

Can I generate slides in languages other than English?​

Yes. Pass the language parameter (ISO 639-1 code) to the API or --lang flag to the CLI:

felo-slides "Kubernetes 入门指南" --lang zh
felo-slides "Introducción a WebAssembly" --lang es

The AI generates content in the specified language while keeping technical terms in their standard form.

How does the OpenClaw skill differ from the Claude Code skill?​

The Claude Code skill is optimized for interactive, in-editor use — it asks clarifying questions and iterates with you. The OpenClaw skill is designed for autonomous agent workflows — it takes structured input and returns output without back-and-forth. Same engine, different interaction model.

Start Building​

Here's the quick-start checklist:

  1. Get an API key → slides.felo.ai/settings/api
  2. Install the CLI → npm install -g felo-slides
  3. Set your key → export FELO_SLIDES_API_KEY=fsk_...
  4. Generate your first deck → felo-slides "Your topic here"
  5. Add to Claude Code → claude skill add felo-slides
  6. Automate → wire the API into your workflows

Felo Slides isn't trying to replace your design tool. It's trying to make the "I need a quick deck" problem go away — especially when you're already living in the terminal, your editor, or an agent workflow.

The AI slides you generate this way aren't perfect first drafts. They're useful first drafts. The kind you actually open, tweak for 10 minutes, and ship. That's the bar.

Try it:

npx felo-slides "The talk I've been meaning to give"

→ Felo Slides · npm package · API docs · GitHub

This post is also available in 简体中文, 日本語, 한국어, 繁體中文, हिन्दी, Français, العربية, Русский, اردو, Bahasa Indonesia, Deutsch, Tiếng Việt, Türkçe, Italiano, ไทย, Español, বাংলা and Português.