Cómo usar Felo Slides con Claude Code y agentes de IA

Crea diapositivas impulsadas por IA desde la terminal usando Felo Slides con Claude Code, OpenClaw y el paquete npm felo-slides. Una guía para desarrolladores sobre la generación programática de diapositivas.

$ 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

Y eso es todo. Sin navegador. Sin arrastrar y soltar. Sin selector de plantillas. Escribiste un solo comando, y aparecieron ocho diapositivas.

Si alguna vez has estado en una reunión de 40 minutos que debería haber sido una presentación, ya sabes por qué creamos Felo Slides. Pero esta publicación no trata sobre la aplicación web, sino sobre lo que sucede cuando le das a los desarrolladores una API y les dices que automaticen todo.

Aquí te mostramos cómo usar Felo Slides con Claude Code, agentes OpenClaw y tus propios scripts para generar diapositivas con IA sin salir de la terminal.

[IMG: Captura de pantalla de la terminal mostrando la CLI de felo-slides generando una presentación a partir de una sola instrucción, con el archivo de salida resaltado]

¿Qué es Felo Slides (para desarrolladores)?

Felo Slides es un motor de presentaciones con IA. La mayoría lo conoce como una aplicación web en slides.felo.ai. Detrás de escena, también es:

• Paquete npm felo-slides — una CLI y biblioteca para generar diapositivas de forma programática
• Habilidad de Claude Code — una habilidad nativa que permite a Claude Code crear presentaciones directamente
• Habilidad de OpenClaw — la misma idea, integrada al marco de agentes OpenClaw
• API REST — endpoints HTTP para generación de diapositivas, análisis de temas y renderizado de plantillas

La aplicación web es el front‑end pulido. Las herramientas para desarrolladores son el motor. Puedes combinar y mezclar: usa la CLI para generación local rápida, la API para automatización del lado del servidor o la habilidad de Claude Code para crear presentaciones por conversación.

Cuándo usar cada uno:

Caso de uso	Herramienta
Diapositivas rápidas desde la terminal	CLI felo-slides
Generación conversacional en tu editor	Habilidad Claude Code
Flujos impulsados por agentes	Habilidad OpenClaw
Backend / CI / trabajos por lotes	API de Felo Slides

Instalación y configuración

Requisitos previos

• Node.js 18+ (recomendado 20+)
• Una cuenta de Felo con acceso a la API (el nivel gratuito funciona)
• Una clave de API desde slides.felo.ai/settings/api

Instalar el paquete npm

npm install -g felo-slides

O úsalo sin instalar:

npx felo-slides "Your presentation topic here"

Autenticación

Configura tu clave de API como variable de entorno:

export FELO_SLIDES_API_KEY=fsk_your_api_key_here

O crea un archivo .felo-slides.json en la raíz de tu proyecto:

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

Verificar que funciona

$ felo-slides --version
felo-slides 2.4.0

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

[IMG: Comparación lado a lado del resultado en terminal mostrando configuración exitosa vs. errores comunes de autenticación]

Uso de Felo Slides con Claude Code

Aquí es donde se pone interesante. La habilidad de Claude Code convierte el editor de Claude en una fábrica de diapositivas. En lugar de escribir indicaciones y copiar resultados, Claude genera, edita y exporta presentaciones directamente.

Instalar la habilidad de Claude Code

# En tu directorio de proyecto de Claude Code
claude skill add felo-slides

Esto registra la habilidad Felo Slides en Claude Code. Claude ahora sabe que puede crear presentaciones y tiene acceso completo a la API de felo-slides.

Uso básico en Claude Code

Una vez instalada, simplemente pídele a Claude de forma natural:

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

Claude hará lo siguiente:

1. Redacta un esquema y confirma la estructura contigo
2. Genera el contenido de las diapositivas usando la API de Felo Slides
3. Guarda el archivo .felo en tu directorio de proyecto
4. Ofrece iterar en diapositivas específicas

Sin cambiar de contexto. Sin copiar y pegar. Las diapositivas viven en tu repositorio junto a tu código.

Avanzado: plantillas personalizadas en Claude Code

Puedes definir plantillas de diapositivas específicas del proyecto que Claude usará automáticamente:

mkdir -p .felo/templates

Crea .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"
  }
}

Luego, en Claude Code:

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

Claude detecta la plantilla automáticamente y la aplica a cada diapositiva generada.

[IMG: Editor de Claude Code mostrando una conversación en la que el usuario pide una presentación, Claude genera el esquema y aparece el archivo .felo en el árbol de archivos]

Edición conversacional de diapositivas

El verdadero poder de la integración con Claude Code es la edición iterativa:

> 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.

Cada edición es una llamada API detrás de escena, pero nunca ves la solicitud HTTP. Claude se encarga de todo el proceso.

Uso de Felo Slides con OpenClaw

OpenClaw lleva el enfoque de agentes un paso más allá. La habilidad Felo Slides para OpenClaw permite que los agentes de IA generen diapositivas como parte de flujos de trabajo más amplios, no solo en respuesta a comandos directos.

Configuración

openclaw skill install felo-slides

Configura en tu espacio de trabajo de OpenClaw:

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

Generación de diapositivas impulsada por agentes

Con OpenClaw, puedes activar la generación de diapositivas desde flujos de trabajo de agentes:

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?"

El agente obtuvo contexto de dos herramientas externas, lo estructuró en una presentación y generó las diapositivas, todo en un solo paso.

[IMG: Diagrama que muestra el flujo de trabajo del agente OpenClaw: solicitud del usuario → recopilación de contexto (Notion, Linear) → API de felo-slides → archivo de salida → entrega]

Ejemplos de línea de comandos

Veamos la CLI con más detalle. Estos ejemplos cubren los flujos de trabajo más comunes para desarrolladores.

Generar desde un tema

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

Generar desde un archivo Markdown

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

La CLI analiza tu markdown, detecta encabezados y viñetas, y los asigna automáticamente a diapositivas.

Generar desde una URL

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

Útil para convertir documentación, publicaciones de blog o RFCs en presentaciones.

Generación por lotes

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

Donde topics.txt contiene un tema por línea:

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

Formatos de exportación

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

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

# Exportar a imágenes (un PNG por diapositiva)
felo-slides export ./output.felo --format png --dpi 300

Integración en CI/CD

# .github/workflows/weekly-deck.yml
name: Generate Weekly Update Deck
on:
  schedule:
    - cron: '0 9 * * 1'  # Cada lunes a las 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: Registro de ejecución de GitHub Actions mostrando el paso felo-slides completado exitosamente, con la presentación generada listada bajo Artifacts]

Ejemplos de flujos de automatización

Aquí hay tres flujos de trabajo reales donde Felo Slides ahorra tiempo significativo.

1. Bot de preparación previa a reuniones

Un bot de Slack que genera una presentación inicial antes de cada reunión recurrente:

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. Canalización Documentación → Presentación

Convierte automáticamente nuevos RFCs o documentos de diseño en borradores de diapositivas:

#!/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

Conéctalo como un gancho de git o paso en CI, y cada nuevo RFC obtendrá automáticamente una presentación asociada.

3. Reutilización de contenido en múltiples formatos

Convierte una pieza de contenido en una publicación de blog, una presentación y un hilo social:

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);

  // Generar los tres formatos en 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 };
}

Una fuente, tres resultados. La presentación no es una idea posterior: se genera con la misma inteligencia de contenido que el artículo del blog.

[IMG: Diagrama de flujo que muestra un contenido fuente ramificándose en tres salidas: artículo de blog, presentación y hilo en redes sociales]

Referencia de API

Para equipos que construyen integraciones personalizadas, la API de Felo Slides expone tres endpoints principales.

Autenticación

Todas las solicitudes requieren una clave de API en el encabezado:

Authorization: Bearer fsk_your_api_key_here

POST /v1/slides/generate

Genera una nueva presentación.

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"
  }'

Respuesta:

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

GET /v1/slides/{id}

Verifica el estado y recupera una presentación completada.

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

Respuesta (cuando está completa):

{
  "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

Modifica una presentación existente de forma programática.

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 }
    ]
  }'

Límites de uso

• Nivel gratuito: 50 solicitudes/día, 5 solicitudes/minuto
• Nivel Pro: 500 solicitudes/día, 30 solicitudes/minuto
• Empresarial: límites personalizados

La CLI felo-slides y todos los SDK manejan el límite de velocidad automáticamente con retroceso exponencial.

[IMG: Captura de la documentación de API mostrando los tres endpoints con ejemplos de solicitud y respuesta]

Preguntas frecuentes

¿Puedo usar Felo Slides sin conexión?

El paso de generación requiere una llamada API (el modelo de IA se ejecuta en el servidor). Pero puedes exportar las presentaciones a PDF o PPTX y trabajar con ellas localmente después. La CLI almacena en caché tus últimas 10 presentaciones para visualización sin conexión.

¿Cómo manejo contenido sensible?

Todas las solicitudes API están encriptadas en tránsito (TLS 1.3) y en reposo. El contenido de las diapositivas no se utiliza para entrenar el modelo. Para implementaciones empresariales con requisitos de residencia de datos, contáctanos para opciones on‑premise.

¿Puedo usar mis propias plantillas?

Sí. El paquete npm y la API admiten plantillas personalizadas. Define tu plantilla como un archivo JSON (ver la sección de Claude Code arriba) y luego haz referencia a ella por nombre o ruta:

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

¿Cuál es el formato de salida?

Las presentaciones generadas se almacenan como archivos .felo (un formato JSON estructurado). Puedes exportar a PDF, PPTX, PNG o HTML. El formato .felo es editable: puedes modificarlo programáticamente o volver a importarlo para más ediciones con IA.

¿La habilidad de Claude Code funciona con Claude CLI o solo con la app de escritorio?

Con ambos. La habilidad funciona con claude en la terminal y con la aplicación de escritorio de Claude. La instalación es la misma en ambos casos.

¿Puedo generar diapositivas en otros idiomas distintos del inglés?

Sí. Pasa el parámetro language (código ISO 639‑1) a la API o la opción --lang a la CLI:

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

La IA genera el contenido en el idioma especificado manteniendo los términos técnicos en su forma estándar.

¿En qué se diferencia la habilidad de OpenClaw de la de Claude Code?

La habilidad de Claude Code está optimizada para uso interactivo en el editor: hace preguntas aclaratorias e itera contigo. La habilidad de OpenClaw está diseñada para flujos de trabajo autónomos de agentes: toma entrada estructurada y devuelve salida sin interacción. Mismo motor, distinto modelo de interacción.

Comienza a construir

Aquí tienes la lista de inicio rápido:

1. Obtén una clave de API → slides.felo.ai/settings/api
2. Instala la CLI → npm install -g felo-slides
3. Configura tu clave → export FELO_SLIDES_API_KEY=fsk_...
4. Genera tu primera presentación → felo-slides "Your topic here"
5. Agrégalo a Claude Code → claude skill add felo-slides
6. Automatiza → integra la API en tus flujos de trabajo

Felo Slides no intenta reemplazar tu herramienta de diseño. Intenta eliminar el problema de “necesito una presentación rápida”, especialmente cuando ya estás trabajando en la terminal, tu editor o un flujo de agentes.

Las diapositivas generadas de esta forma no son borradores perfectos. Son buenos borradores iniciales. Del tipo que realmente abres, ajustas por 10 minutos y entregas. Ese es el objetivo.

Pruébalo:

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

→ Felo Slides · paquete npm · documentación de API · GitHub

---

Esta publicación también está disponible en English, 简体中文, 日本語, 한국어, 繁體中文, हिन्दी, Français, العربية, Русский, اردو, Bahasa Indonesia, Deutsch, Tiếng Việt, Türkçe, Italiano, ไทย, বাংলা and Português.