Implémenter un flux RSS avec Claude Code : guide RSS 2.0, Atom et Astro

RSS reste un canal fiable pour les contenus techniques

Publier un article ne suffit pas. Les lecteurs arrivent par recherche, réseaux sociaux, newsletter, Slack ou lecteur RSS. Un flux RSS est un fichier XML qui expose titre, lien, description, date et catégories. XML est strict : un & non échappé peut rendre le flux invalide.

Atom est un format voisin défini par le RFC 4287. Pour un site statique, commencez avec RSS 2.0 puis ajoutez Atom si une intégration l’exige. Avec Claude Code, l’objectif n’est pas seulement de générer du texte XML, mais de verrouiller les détails : échappement XML, dates, URL absolues, flux par langue, validation et cache.

Les références primaires sont RSS Advisory Board RSS 2.0 Specification, IETF RFC 4287, W3C Feed Validation Service et Astro RSS recipe. Pour le reste du workflow éditorial, voir Blog CMS avec Claude Code, SEO avec Claude Code et génération de sitemap.

Cas d’usage concrets

Premier cas : fidéliser les lecteurs d’un blog technique. Les utilisateurs de Feedly, Inoreader ou d’un lecteur auto-hébergé consultent souvent beaucoup de sources. RSS place vos articles dans leur routine sans dépendre d’un réseau social.

Deuxième cas : diffuser la connaissance interne. Notes de version, postmortems, alertes sécurité et décisions d’architecture peuvent alimenter le même flux. Un portail interne et un bot Slack lisent alors la même source que le site.

Troisième cas : publier en plusieurs langues. Un site français, anglais, japonais et espagnol doit éviter un flux mélangé. /fr/rss.xml doit lire la collection française, utiliser /fr/blog/ et annoncer language correctement.

Quatrième cas : monétisation. Pour ClaudeCodeLab, un flux aide les lecteurs réguliers à revenir vers des guides, modèles, produits ou formation et conseil Claude Code. Le CTA doit être une suite utile de l’article.

Définir le contrat du flux

Avant de demander du code à Claude Code, écrivez les règles.

Point	Choix recommandé	Pourquoi
Format	RSS 2.0 d’abord, Atom ensuite	Simple et largement supporté
URL	Absolues	Les lecteurs externes ouvrent correctement les liens
Dates	toUTCString() pour RSS, toISOString() pour Atom	Moins d’erreurs de tri
Corps	Description au départ	Le HTML complet demande sanitize et réécriture d’images
Limite	20 à 50 articles	Flux rapide et facile à vérifier
Cache	Politique explicite	Évite les flux périmés après publication
Validation	Script local et W3C Validator	Le navigateur ne suffit pas

RSS 2.0 utilise channel pour le site et item pour chaque article. guid doit identifier l’article de façon stable, souvent avec le permalink.

Générateur RSS sans dépendance

Enregistrez ce fichier dans scripts/generate-rss.mjs, puis lancez 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: "Implémenter RSS avec Claude Code",
    description: "Générer et valider un flux RSS 2.0 pour un site statique.",
    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(`/fr/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 France</title>
    <link>${siteUrl}/fr/</link>
    <description>Guides pratiques Claude Code</description>
    <language>fr</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}`);

Les protections importantes sont escapeXml(), new URL() et la validation de date. Claude Code doit les conserver pendant les refactorings.

Implémentation Astro

Astro propose le paquet officiel @astrojs/rss.

npm install @astrojs/rss

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

  return rss({
    title: "ClaudeCodeLab France",
    description: "Guides pratiques Claude Code",
    site: context.site,
    items,
    customData: "<language>fr</language><ttl>60</ttl>",
  });
}

Ajoutez la découverte automatique dans le head.

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

Atom, multilingue et validation

Pour Atom, gardez un id stable et une date ISO.

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

Configuration multilingue :

const feeds = [
  { collection: "blog", prefix: "", language: "ja", title: "ClaudeCodeLab" },
  { collection: "blog-en", prefix: "/en", language: "en", title: "ClaudeCodeLab English" },
  { collection: "blog-fr", prefix: "/fr", language: "fr", title: "ClaudeCodeLab France" },
];

Script de vérification locale :

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

Les pièges fréquents sont concrets : R&D non échappé, brouillons exposés, URL relatives, dates ambiguës, flux français pointant vers l’anglais, cache CDN trop long.

Prompt Claude Code et test pratique

Implémente RSS 2.0 pour ce site Astro.
- Modifie seulement src/pages/fr/rss.xml.ts.
- Utilise @astrojs/rss.
- Exclue les brouillons.
- Trie par updatedDate ou pubDate, plus récent d’abord.
- Limite à 30 articles.
- Garde le préfixe /fr/blog/.
- Ajoute language et ttl.
- Rapporte les commandes et résultats.

Relis l’implémentation de façon critique.
Priorise échappement XML, URL relatives, brouillons, dates, stabilité du guid, préfixes multilingues, cache et validation W3C.

J’ai testé ce workflow sur un petit jeu de données Astro. Le script local a repéré un & non échappé et un guid non absolu avant l’ouverture dans le navigateur. La revue humaine reste nécessaire pour la qualité de traduction, la pertinence du CTA et l’affichage dans un vrai lecteur. Pour industrialiser RSS, sitemap, QA éditoriale et conversion, commencez par formation et conseil Claude Code.