Implementar RSS com Claude Code: guia de RSS 2.0, Atom e Astro para sites estáticos

RSS ainda é um canal confiável

Publicar um artigo não garante que ele chegue ao leitor. Busca, redes sociais, newsletter, Slack e leitores RSS são canais diferentes. Um feed RSS é um arquivo XML com título, link, descrição, data e categorias. XML é rígido: um & sem escape pode quebrar o feed.

Atom é um formato parecido, definido pelo RFC 4287. Para a maioria dos sites estáticos, comece com RSS 2.0 e adicione Atom apenas quando uma integração exigir. Com Claude Code, o objetivo é gerar um feed verificável, não apenas um arquivo XML qualquer.

Use fontes primárias: RSS Advisory Board RSS 2.0 Specification, IETF RFC 4287, W3C Feed Validation Service e Astro RSS recipe. Para o fluxo editorial completo, veja Blog CMS com Claude Code, SEO com Claude Code e geração de sitemap.

Casos de uso reais

O primeiro caso é aumentar recorrência em um blog técnico. Quem usa Feedly, Inoreader ou um leitor próprio costuma acompanhar muitas fontes. RSS coloca seu artigo nesse fluxo sem depender de uma rede social.

O segundo caso é distribuição interna. Release notes, postmortems, avisos de segurança e decisões de arquitetura podem alimentar um portal ou bot de Slack usando o mesmo conteúdo.

O terceiro caso é publicação multilíngue. Um site com português, inglês, japonês e espanhol não deve misturar tudo em um único feed. /pt/rss.xml precisa usar a coleção portuguesa, o prefixo /pt/blog/ e language correto.

O quarto caso é monetização. No ClaudeCodeLab, RSS ajuda leitores recorrentes a chegarem a templates, produtos, treinamento e consultoria. A consultoria e treinamento Claude Code deve aparecer como próximo passo útil.

Contrato do feed antes do código

Defina as regras antes de pedir a implementação.

Área	Recomendação	Motivo
Formato	RSS 2.0 primeiro, Atom opcional	Simples e compatível
URLs	Absolutas	Leitores externos abrem corretamente
Datas	toUTCString() para RSS, toISOString() para Atom	Evita ordenação errada
Conteúdo	Comece com description	HTML completo exige sanitização
Limite	20 a 50 artigos	Mantém o feed leve
Cache	Política explícita	Evita feed antigo após publicação
Validação	Script local e W3C Validator	Ver no navegador não basta

RSS 2.0 usa channel para o site e item para artigos. guid deve identificar o artigo de forma estável, normalmente com o permalink.

Gerador RSS sem dependências

Salve como scripts/generate-rss.mjs e execute 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 com Claude Code",
    description: "Gere e valide um feed RSS 2.0 para um site 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(`/pt/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 Português</title>
    <link>${siteUrl}/pt/</link>
    <description>Guias práticos de Claude Code</description>
    <language>pt</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}`);

As proteções principais são escapeXml(), new URL() e validação de data. Claude Code não deve removê-las em refatorações.

Implementação no Astro

Use o pacote oficial @astrojs/rss.

npm install @astrojs/rss

// src/pages/pt/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-pt", ({ 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: `/pt/blog/${post.id}/`,
      categories: post.data.tags,
    }));

  return rss({
    title: "ClaudeCodeLab Português",
    description: "Guias práticos de Claude Code",
    site: context.site,
    items,
    customData: "<language>pt</language><ttl>60</ttl>",
  });
}

Adicione descoberta automática no head.

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

Atom, multilíngue e validação

Atom precisa de id estável e data ISO.

function atomEntry(post, siteUrl) {
  const url = new URL(`/pt/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>`;
}

Mantenha collection, prefix e language juntos:

const feeds = [
  { collection: "blog", prefix: "", language: "ja", title: "ClaudeCodeLab" },
  { collection: "blog-en", prefix: "/en", language: "en", title: "ClaudeCodeLab English" },
  { collection: "blog-pt", prefix: "/pt", language: "pt", title: "ClaudeCodeLab Português" },
];

Valide localmente:

// scripts/check-feed.mjs
const feedUrl = process.argv[2] ?? "http://localhost:4321/pt/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}`);

Falhas comuns: R&D sem escape, draft publicado, URL relativa, data ambígua, feed português apontando para páginas em inglês e cache CDN longo demais.

Prompt e verificação

Implemente RSS 2.0 para este site Astro.
- Edite apenas src/pages/pt/rss.xml.ts.
- Use @astrojs/rss.
- Exclua drafts.
- Ordene por updatedDate ou pubDate, mais recente primeiro.
- Limite a 30 artigos.
- Mantenha o prefixo /pt/blog/.
- Adicione language e ttl.
- Relate comandos e validação.

Revise a implementação RSS de forma crítica.
Priorize XML escaping, URLs relativas, drafts, formato de data, guid estável, prefixos multilíngues, cache e validação W3C.

Testei esse fluxo em um pequeno conjunto de dados estilo Astro. O script local detectou & sem escape e guid não absoluto antes do navegador. A revisão humana ainda avaliou tradução, CTA e exibição em um leitor real. Para transformar RSS, sitemap, QA editorial e conversão em processo de equipe, comece por treinamento e consultoria Claude Code.