Skip to main content

Como usar o Felo Slides com Claude Code e Agentes de IA

· 13 minutos de leitura
Felo Search Tips Buddy
Felo Search Tips Buddy
Committed to answers at your fingertips

Crie slides com IA diretamente do terminal usando Felo Slides com Claude Code, OpenClaw e o pacote npm felo-slides. Um guia para desenvolvedores sobre geração programática de apresentações.

$ npx felo-slides "Explique o agendamento de pods do Kubernetes em 8 slides"
✓ Analisando tópico...
✓ Gerando estrutura (8 slides)...
✓ Criando conteúdo dos slides...
✓ Construindo apresentação...
✔ Concluído → kubernetes-pod-scheduling.felo

É isso. Sem navegador. Sem arrastar e soltar. Sem escolher modelos. Você digitou um comando e oito slides apareceram.

Se você já passou por uma reunião de 40 minutos que poderia ter sido um conjunto de slides, já entende por que criamos o Felo Slides. Mas este post não é sobre o app web — é sobre o que acontece quando você dá a desenvolvedores uma API e diz para automatizar tudo.

Veja como usar o Felo Slides com Claude Code, agentes OpenClaw e seus próprios scripts para gerar slides com IA sem sair do terminal.

[IMG: Captura de tela do terminal mostrando o CLI do felo-slides gerando uma apresentação a partir de um único comando, com o arquivo de saída destacado]

O que é o Felo Slides (para Desenvolvedores)?​

O Felo Slides é um mecanismo de apresentações com IA. A maioria o conhece como um app web em slides.felo.ai. Mas por trás dele, também é:

  • Pacote npm felo-slides — um CLI e biblioteca para gerar slides programaticamente
  • Claude Code Skill — uma habilidade nativa que permite ao Claude Code criar apresentações diretamente
  • OpenClaw Skill — mesmo conceito, mas integrado ao framework de agentes OpenClaw
  • API REST — endpoints HTTP para geração de slides, análise de tópicos e renderização de modelos

O app web é a interface polida. As ferramentas de desenvolvedor são o motor. Você pode misturar e combinar: usar o CLI para gerar localmente, a API para automação no servidor ou a habilidade do Claude Code para construir apresentações de forma conversacional.

Quando usar qual:

Caso de usoFerramenta
Slides rápidos via terminalCLI felo-slides
Geração conversacional no editorClaude Code Skill
Fluxos orientados por agenteOpenClaw Skill
Backend / CI / tarefas em loteFelo Slides API

Instalação e Configuração​

Pré-requisitos​

  • Node.js 18+ (recomendado 20+)
  • Conta Felo com acesso à API (o plano gratuito funciona)
  • Uma chave de API em slides.felo.ai/settings/api

Instalar o pacote npm​

npm install -g felo-slides

Ou usar sem instalar:

npx felo-slides "Seu tópico de apresentação aqui"

Autenticação​

Defina sua chave de API como variável de ambiente:

export FELO_SLIDES_API_KEY=fsk_sua_chave_aqui

Ou crie um .felo-slides.json na raiz do projeto:

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

Verificar se está funcionando​

$ felo-slides --version
felo-slides 2.4.0

$ felo-slides --check
✓ Chave de API válida
✓ Limite de uso: 47/50 requisições restantes
✓ Modelos carregados: 12

[IMG: Comparação lado a lado do terminal mostrando configuração bem-sucedida versus erros comuns de autenticação]

Usando o Felo Slides com Claude Code​

É aqui que fica interessante. A habilidade Claude Code transforma o editor do Claude em uma fábrica de slides. Em vez de escrever prompts e copiar resultados, o Claude gera, edita e exporta apresentações diretamente.

Instalar a habilidade Claude Code​

# No diretório do seu projeto Claude Code
claude skill add felo-slides

Isso registra a habilidade Felo Slides no Claude Code. Agora o Claude sabe que pode criar apresentações e tem acesso completo à API do felo-slides.

Uso básico no Claude Code​

Depois de instalado, basta pedir naturalmente:

> Crie uma apresentação de 10 slides sobre o plano de engenharia do 3º trimestre.
  Inclua seções sobre: migração de plataforma, plano de contratação
  e orçamento de infraestrutura.

Claude irá:

  1. Esboçar a estrutura e confirmar com você
  2. Gerar o conteúdo usando a API do Felo Slides
  3. Salvar o arquivo .felo no diretório do projeto
  4. Oferecer para iterar em slides específicos

Sem alternar de contexto. Sem copiar e colar. Os slides vivem no seu repositório junto com o código.

Avançado: Modelos personalizados no Claude Code​

Você pode definir modelos de slides específicos de projeto para o Claude usar automaticamente:

mkdir -p .felo/templates

Crie .felo/templates/engineering.json:

{
  "name": "Atualização de Engenharia",
  "theme": "dark",
  "accent": "#6366f1",
  "fonts": {
    "heading": "JetBrains Mono",
    "body": "Inter"
  },
  "layout": {
    "titleSlide": "code-hero",
    "contentSlide": "split-left",
    "closingSlide": "cta-minimal"
  }
}

Então, no Claude Code:

> Faça uma apresentação sobre a migração do serviço de autenticação.
  Use o modelo engineering.

O Claude detecta o modelo automaticamente e o aplica a todos os slides gerados.

[IMG: Editor do Claude Code mostrando uma conversa onde o usuário pede um deck, o Claude gera uma estrutura e o arquivo .felo aparece na árvore do projeto]

Editando slides de forma conversacional​

O verdadeiro poder da integração com o Claude Code está na edição iterativa:

> O slide 3 está muito denso. Divida-o em dois.
  Mova o diagrama de arquitetura para o slide 4.

> Adicione anotações do apresentador aos slides 5-7.
  Máximo de 50 palavras cada.

> Troque a cor de destaque para o verde da marca (#10b981)
  e adicione nosso logo ao slide de título.

Cada edição é uma chamada à API por trás dos panos, mas você nunca vê a requisição HTTP. O Claude cuida disso.

Usando o Felo Slides com OpenClaw​

O OpenClaw leva a abordagem de agentes ainda mais longe. A habilidade Felo Slides para OpenClaw permite que agentes de IA gerem slides como parte de fluxos maiores — não apenas em resposta a comandos diretos.

Configuração​

openclaw skill install felo-slides

Configure em seu workspace OpenClaw:

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

Geração de slides orientada por agente​

Com o OpenClaw, você pode acionar a geração de slides dentro dos fluxos de trabalho do agente:

Usuário: Fechamos o contrato com a Acme. Prepare um deck
         de kickoff para o time de engenharia. Use o resumo
         do Notion e o cronograma do Linear.

Agente: [lê o resumo do Notion]
        [busca o cronograma do Linear]
        [gera um deck de 12 slides via felo-slides]
        [salva em output/slides/acme-kickoff.felo]
        "Pronto. Criei um deck de 12 slides cobrindo escopo,
         cronograma, atribuições de equipe e marcos.
         Quer que eu envie para #eng-general?"

O agente extraiu contexto de duas ferramentas externas, estruturou em uma apresentação e gerou os slides — tudo em uma única execução.

[IMG: Diagrama mostrando o fluxo de trabalho do agente OpenClaw: solicitação do usuário → coleta de contexto (Notion, Linear) → API felo-slides → arquivo de saída → entrega]

Exemplos via Linha de Comando​

Vamos analisar o CLI em mais detalhe. Estes exemplos cobrem os fluxos mais comuns para desenvolvedores.

Gerar a partir de um tópico​

felo-slides "Microsserviços vs monólitos: um guia pragmático" --slides 12

Gerar a partir de um arquivo Markdown​

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

O CLI analisa seu markdown, detecta títulos e marcadores e os converte automaticamente em slides.

Gerar a partir de uma URL​

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

Útil para transformar documentação, posts de blog ou RFCs em apresentações.

Geração em lote​

# Gerar slides para múltiplos tópicos
felo-slides batch --file topics.txt --output ./deck-batch/

Onde topics.txt contém um tópico por linha:

Revisão de OKRs do 4º trimestre
Integração de novos membros: Backend
Post-mortem de incidente: Falha de 12-05-2026
Registro de decisão de arquitetura: Event Sourcing

Formatos de exportação​

# Exportar para PDF
felo-slides export ./output.felo --format pdf

# Exportar para PPTX
felo-slides export ./output.felo --format pptx

# Exportar para imagens (um PNG por slide)
felo-slides export ./output.felo --format png --dpi 300

Integração com CI/CD​

# .github/workflows/weekly-deck.yml
name: Gerar Deck de Atualização Semanal
on:
  schedule:
    - cron: '0 9 * * 1'  # Toda segunda às 9h

jobs:
  generate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npx felo-slides "Atualização semanal de engenharia para ${{ github.run_id }}" --template weekly --output ./decks/
      - uses: actions/upload-artifact@v4
        with:
          name: weekly-deck
          path: ./decks/

[IMG: Log de execução do GitHub Actions mostrando a etapa do felo-slides concluída com sucesso, com o deck gerado listado em Artifacts]

Exemplos de Fluxos de Automação​

Aqui estão três fluxos reais em que o Felo Slides economiza bastante tempo.

1. Bot de Preparação de Reunião​

Um bot do Slack que gera um deck inicial antes de cada reunião recorrente:

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: [
      `Participantes: ${context.attendees.join(', ')}`,
      `Ações anteriores: ${context.lastActions.join('; ')}`,
      `Agenda: ${context.agenda.join(', ')}`,
    ],
    template: 'standup',
  });

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

2. Pipeline de Documentação → Apresentação​

Converter automaticamente novos RFCs ou documentos de design em rascunhos de apresentação:

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

# Detectar novos arquivos .md em /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 "Gerados slides para: $TITLE → $OUTPUT"
done

Conecte isso como um hook de git ou etapa de CI, e todo novo RFC ganha automaticamente um conjunto de slides associado.

3. Reaproveitamento de Conteúdo Multi-Formato​

Transforme um único conteúdo em post de blog, deck de slides e thread para redes sociais:

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

async function repurposeContent(sourceUrl: string) {
  // Buscar e analisar o conteúdo original
  const content = await fetchAndParse(sourceUrl);

  // Gerar os três formatos em paralelo
  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 };
}

Uma fonte, três saídas. O deck de slides não é um complemento — é gerado com a mesma inteligência de conteúdo que o post do blog.

[IMG: Fluxograma mostrando um conteúdo fonte gerando três saídas: post de blog, deck de slides e thread de mídia social]

Referência da API​

Para equipes que constroem integrações personalizadas, a API do Felo Slides expõe três endpoints principais.

Autenticação​

Todas as requisições requerem uma chave de API no cabeçalho:

Authorization: Bearer fsk_sua_chave_aqui

POST /v1/slides/generate​

Gerar uma nova apresentação.

curl -X POST https://api.slides.felo.ai/v1/slides/generate \
  -H "Authorization: Bearer fsk_sua_chave_aqui" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "Introdução ao WebAssembly",
    "slideCount": 10,
    "template": "developer-dark",
    "context": [
      "Público: engenheiros backend sêniores",
      "Foco em casos práticos, não teoria",
      "Incluir comparação de desempenho com Docker"
    ],
    "language": "en"
  }'

Resposta:

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

GET /v1/slides/{id}​

Verificar status e recuperar um deck completo.

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

Resposta (quando completo):

{
  "id": "deck_abc123",
  "status": "complete",
  "slides": [
    {
      "number": 1,
      "title": "O que é 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​

Modificar um deck existente programaticamente.

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

Limites de Uso​

  • Plano gratuito: 50 requisições/dia, 5 requisições/minuto
  • Plano Pro: 500 requisições/dia, 30 requisições/minuto
  • Enterprise: limites personalizados

O CLI felo-slides e todos os SDKs lidam automaticamente com limites usando backoff exponencial.

[IMG: Captura de tela da documentação da API mostrando os três endpoints com exemplos de requisição/resposta]

Perguntas Frequentes (FAQ)​

Posso usar o Felo Slides offline?​

A etapa de geração requer uma chamada de API (o modelo de IA roda no servidor). Mas você pode exportar decks para PDF ou PPTX e trabalhar localmente depois. O CLI armazena em cache seus 10 decks mais recentes para visualização offline.

Como lidar com conteúdo sensível?​

Todas as requisições são criptografadas em trânsito (TLS 1.3) e em repouso. O conteúdo dos slides não é usado para treinar modelos. Para implantações corporativas com requisitos de residência de dados, entre em contato sobre opções on-premise.

Posso usar meus próprios modelos?​

Sim. O pacote npm e a API suportam modelos personalizados. Defina seu modelo como um arquivo JSON (veja a seção do Claude Code acima) e referencie-o por nome ou caminho:

felo-slides "Tópico aqui" --template ./meu-modelo.json

Qual é o formato de saída?​

Os decks gerados são armazenados como arquivos .felo (um formato JSON estruturado). Você pode exportar para PDF, PPTX, PNG ou HTML. O formato .felo é editável — você pode modificá-lo programaticamente ou reimportá-lo para novas edições por IA.

A habilidade Claude Code funciona com Claude CLI ou só no app desktop?​

Ambos. A habilidade funciona com claude no terminal e com o aplicativo desktop do Claude. A instalação é a mesma.

Posso gerar slides em outros idiomas além do inglês?​

Sim. Passe o parâmetro language (código ISO 639-1) para a API ou a flag --lang para o CLI:

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

A IA gera o conteúdo no idioma especificado, mantendo os termos técnicos em sua forma padrão.

Qual é a diferença entre a habilidade OpenClaw e a do Claude Code?​

A habilidade Claude Code é otimizada para uso interativo — faz perguntas e itera com você. Já a OpenClaw é feita para fluxos autônomos de agentes — recebe entrada estruturada e retorna a saída sem interação. Mesmo motor, modelo de interação diferente.

Comece a Construir​

Aqui está o checklist de início rápido:

  1. Obtenha uma chave de API → slides.felo.ai/settings/api
  2. Instale o CLI → npm install -g felo-slides
  3. Defina sua chave → export FELO_SLIDES_API_KEY=fsk_...
  4. Gere seu primeiro deck → felo-slides "Seu tópico aqui"
  5. Adicione ao Claude Code → claude skill add felo-slides
  6. Automatize → conecte a API aos seus fluxos de trabalho

O Felo Slides não tenta substituir sua ferramenta de design. Ele quer eliminar o problema do “preciso de um deck rápido” — especialmente quando você já está no terminal, no editor ou em um fluxo de agente.

Os slides gerados dessa forma não são rascunhos perfeitos. São rascunhos úteis. Aqueles que você realmente abre, ajusta por 10 minutos e envia. Esse é o objetivo.

Experimente:

npx felo-slides "A palestra que eu venho adiando"

→ Felo Slides · pacote npm · docs da API · GitHub

Este post também está disponível em English, 简体中文, 日本語, 한국어, 繁體中文, हिन्दी, Français, العربية, Русский, اردو, Bahasa Indonesia, Deutsch, Tiếng Việt, Türkçe, Italiano, ไทย, Español and বাংলা.