Implementar RSS con Claude Code: guía práctica para sitios estáticos y Atom

RSS sigue siendo un canal útil para contenido técnico

Publicar un artículo no garantiza que el lector lo vea. La búsqueda, las redes sociales, el correo, Slack y los lectores RSS son entradas distintas. Un feed RSS es un archivo XML que expone título, enlace, descripción, fecha y categorías de cada artículo. XML es estricto: un & sin escapar puede romper todo el documento.

Atom es un formato parecido, definido por RFC 4287. Para la mayoría de sitios estáticos conviene empezar con RSS 2.0 y añadir Atom solo si una integración lo pide. En esta guía usaremos Claude Code, pero con requisitos verificables: escape XML, fechas, URL absolutas, feeds por idioma, validación, caché y prompts de revisión.

Consulta las fuentes primarias: RSS Advisory Board RSS 2.0 Specification, IETF RFC 4287, W3C Feed Validation Service y Astro RSS recipe. Para el flujo completo del sitio, revisa Blog CMS con Claude Code, SEO con Claude Code y sitemap con Claude Code.

Casos de uso reales

El primer caso es fidelizar lectores de un blog técnico. Quien usa Feedly, Inoreader o un lector propio suele leer muchas fuentes. Si tu artículo entra en su feed, no depende de una publicación social ni de que recuerde tu dominio.

El segundo caso es distribución interna. Notas de versión, postmortems, avisos de seguridad y decisiones de arquitectura pueden salir del mismo origen de contenido y alimentar un portal o un bot de Slack.

El tercer caso es SEO multilingüe. Un sitio con español, inglés, japonés y portugués no debería mezclar todos los idiomas en un solo feed. /es/rss.xml debe usar la colección española, el prefijo /es/blog/ y language correcto.

El cuarto caso es monetización. En ClaudeCodeLab, RSS ayuda a que artículos prácticos vuelvan a lectores que luego pueden comprar plantillas, descargar recursos o pedir formación y consultoría de Claude Code. La CTA debe ser el siguiente paso lógico, no un anuncio invasivo.

Define el contrato antes de programar

Antes de pedir código a Claude Code, escribe las reglas del feed.

Área	Recomendación	Motivo
Formato	RSS 2.0 primero, Atom opcional	Es simple y compatible
URL	URL absolutas	Los lectores externos no resuelven bien rutas relativas
Fechas	toUTCString() para RSS, toISOString() para Atom	Reduce errores de ordenación
Contenido	Empezar con description	HTML completo requiere sanitizar
Límite	20 a 50 artículos	Mantiene el feed rápido
Caché	Política explícita	Evita feeds obsoletos tras publicar
Validación	Script local y W3C Validator	Ver XML en navegador no basta

RSS 2.0 se basa en channel para el sitio y item para cada artículo. guid identifica la entrada de forma estable, normalmente con el permalink.

Generador RSS sin dependencias

Guarda esto como scripts/generate-rss.mjs y ejecuta node scripts/generate-rss.mjs.

// scripts/generate-rss.mjs
import fs from "node:fs";
import path from "node:path";

const siteUrl = "https://example.com";
const outputPath = path.join(process.cwd(), "dist", "rss.xml");

const posts = [
  {
    title: "Implementar RSS con Claude Code",
    description: "Genera y valida un feed RSS 2.0 para un sitio estático.",
    slug: "claude-code-rss-feed",
    pubDate: "2026-06-02T09:00:00+09:00",
    tags: ["Claude Code", "RSS"],
  },
];

function escapeXml(value) {
  return String(value ?? "")
    .replace(/&/g, "&")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&apos;");
}

function toRssDate(value) {
  const date = new Date(value);
  if (Number.isNaN(date.getTime())) throw new Error(`Invalid date: ${value}`);
  return date.toUTCString();
}

const items = posts.map((post) => {
  const url = new URL(`/es/blog/${post.slug}/`, siteUrl).toString();
  return `    <item>
      <title>${escapeXml(post.title)}</title>
      <link>${url}</link>
      <guid isPermaLink="true">${url}</guid>
      <description>${escapeXml(post.description)}</description>
      <pubDate>${toRssDate(post.pubDate)}</pubDate>
    </item>`;
}).join("\n");

const xml = `<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>ClaudeCodeLab Español</title>
    <link>${siteUrl}/es/</link>
    <description>Guías prácticas de Claude Code</description>
    <language>es</language>
    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
    <ttl>60</ttl>
${items}
  </channel>
</rss>
`;

fs.mkdirSync(path.dirname(outputPath), { recursive: true });
fs.writeFileSync(outputPath, xml, "utf8");
console.log(`Generated ${outputPath}`);

Las piezas críticas son escapeXml(), new URL() y la validación de fecha. Claude Code puede refactorizar, pero no debería eliminar estas protecciones.

Implementación en Astro

Astro ofrece el paquete oficial @astrojs/rss. Asegúrate de tener site en astro.config.mjs.

npm install @astrojs/rss

// src/pages/es/rss.xml.ts
import rss from "@astrojs/rss";
import { getCollection } from "astro:content";

export async function GET(context: { site: URL }) {
  const posts = await getCollection("blog-es", ({ data }) => !data.draft);

  const items = posts
    .sort((a, b) => {
      const aDate = new Date(a.data.updatedDate ?? a.data.pubDate).getTime();
      const bDate = new Date(b.data.updatedDate ?? b.data.pubDate).getTime();
      return bDate - aDate;
    })
    .slice(0, 30)
    .map((post) => ({
      title: post.data.title,
      description: post.data.description,
      pubDate: post.data.updatedDate ?? post.data.pubDate,
      link: `/es/blog/${post.id}/`,
      categories: post.data.tags,
    }));

  return rss({
    title: "ClaudeCodeLab Español",
    description: "Guías prácticas de Claude Code",
    site: context.site,
    items,
    customData: "<language>es</language><ttl>60</ttl>",
  });
}

Añade enlaces de descubrimiento al head.

<link rel="alternate" type="application/rss+xml" title="ClaudeCodeLab RSS" href="/es/rss.xml" />
<link rel="alternate" type="application/atom+xml" title="ClaudeCodeLab Atom" href="/es/atom.xml" />

Atom, multilingüe y validación

Para Atom, usa id estable y fechas ISO.

function atomEntry(post, siteUrl) {
  const url = new URL(`/es/blog/${post.slug}/`, siteUrl).toString();
  return `  <entry>
    <title>${escapeXml(post.title)}</title>
    <link href="${url}" />
    <id>${url}</id>
    <updated>${new Date(post.pubDate).toISOString()}</updated>
    <summary>${escapeXml(post.description)}</summary>
  </entry>`;
}

Mantén collection, prefix e idioma unidos:

const feeds = [
  { collection: "blog", prefix: "", language: "ja", title: "ClaudeCodeLab" },
  { collection: "blog-en", prefix: "/en", language: "en", title: "ClaudeCodeLab English" },
  { collection: "blog-es", prefix: "/es", language: "es", title: "ClaudeCodeLab Español" },
];

Valida con un script local antes del W3C Validator.

// scripts/check-feed.mjs
const feedUrl = process.argv[2] ?? "http://localhost:4321/es/rss.xml";
const response = await fetch(feedUrl);
const xml = await response.text();
const failures = [];

if (!response.ok) failures.push(`HTTP status is ${response.status}`);
if (!xml.includes("<rss")) failures.push("missing rss root");
if (!xml.includes("<channel>")) failures.push("missing channel");
if (!xml.includes("<item>")) failures.push("missing item");
if (/&(?!amp;|lt;|gt;|quot;|apos;|#\d+;|#x[a-fA-F0-9]+;)/.test(xml)) failures.push("unescaped ampersand");
if (!/<guid[^>]*>https?:\/\//.test(xml)) failures.push("guid should be absolute");

if (failures.length) {
  console.error(failures.map((failure) => `- ${failure}`).join("\n"));
  process.exit(1);
}

console.log(`OK: ${feedUrl}`);

Los fallos típicos son muy concretos: R&D sin escapar, borradores publicados, URL relativas, fechas ambiguas, feed español apuntando a páginas inglesas y caché CDN demasiado larga.

Prompt y verificación práctica

Implementa RSS 2.0 para este sitio Astro.
- Edita solo src/pages/es/rss.xml.ts.
- Usa @astrojs/rss.
- Excluye draft.
- Ordena por updatedDate o pubDate, más reciente primero.
- Limita a 30 artículos.
- Mantén el prefijo /es/blog/.
- Añade language y ttl.
- Reporta comandos y validación.

Revisa críticamente la implementación RSS.
Prioriza XML escaping, URL relativas, borradores, fechas, guid estable, prefijos multilingües, caché y validación W3C.

Probé este flujo con un conjunto pequeño de datos estilo Astro. El script local detectó & sin escapar y guid no absoluto antes de abrir el navegador. Lo que quedó para revisión humana fue la calidad de traducción, la CTA y la visualización en un lector real. Si tu equipo quiere convertir RSS, sitemap, QA editorial y conversión en un proceso repetible, empieza por formación y consultoría de Claude Code.