RSS-Feeds mit Claude Code implementieren: RSS 2.0, Atom und Astro für statische Sites

RSS ist weiterhin ein stabiler Kanal

Ein veröffentlichter Artikel erreicht Leser nicht automatisch. Suche, Social Media, Newsletter, Slack und RSS-Reader sind verschiedene Wege. Ein RSS-Feed ist eine XML-Datei mit Titel, Link, Beschreibung, Datum und Kategorien. XML ist streng: ein nicht escaptes & kann den ganzen Feed ungültig machen.

Atom ist ein ähnliches Format und in RFC 4287 beschrieben. Für statische Sites reicht meistens RSS 2.0 als Start. Atom ergänzt man, wenn eine Integration es verlangt. Mit Claude Code sollte man nicht nur XML generieren lassen, sondern Anforderungen klar prüfen: XML-Escaping, Datumsformat, absolute URLs, Sprachversionen, Validierung und Cache.

Primäre Quellen sind die RSS Advisory Board RSS 2.0 Specification, IETF RFC 4287, der W3C Feed Validation Service und das Astro RSS recipe. Passend dazu: Blog CMS mit Claude Code, SEO mit Claude Code und Sitemap-Erzeugung.

Praktische Use Cases

Erstens: wiederkehrende Leser für ein technisches Blog. Nutzer von Feedly, Inoreader oder eigenen Readern lesen viele Quellen regelmäßig. RSS bringt neue Artikel in diesen Ablauf, ohne Social-Media-Reichweite zu brauchen.

Zweitens: interne Wissensverteilung. Release Notes, Incident Reviews, Security Notices und Architecture Decision Records können denselben Feed nutzen. Ein internes Portal und ein Slack-Bot lesen dann die gleiche Quelle.

Drittens: mehrsprachige SEO. Eine Site mit Deutsch, Englisch, Japanisch und Spanisch sollte keine gemischten Feeds ausliefern. /de/rss.xml muss die deutsche Collection, /de/blog/ und language passend verwenden.

Viertens: Monetarisierung. Auf ClaudeCodeLab verbindet RSS Artikel mit Templates, Produkten, Training und Beratung. Ein guter Artikel bringt nur dann Umsatz, wenn wiederkehrende Leser ihn sehen. Die Claude Code Schulung und Beratung sollte als natürlicher nächster Schritt erscheinen.

Der Feed-Vertrag vor dem Code

Schreibe vor der Implementierung die Regeln auf.

Bereich	Empfehlung	Grund
Format	RSS 2.0 zuerst, Atom optional	Einfach und breit unterstützt
URLs	Absolute URLs	Externe Reader öffnen Links zuverlässig
Daten	toUTCString() für RSS, toISOString() für Atom	Weniger Sortierfehler
Inhalt	Zunächst description	Vollständiges HTML braucht Sanitizing
Limit	20 bis 50 Artikel	Feed bleibt schnell
Cache	Explizite Policy	Weniger veraltete Feeds
Validierung	Lokales Script und W3C Validator	Browseranzeige reicht nicht

RSS 2.0 nutzt channel für die Site und item für Artikel. guid identifiziert den Artikel stabil, oft mit dem Permalink.

RSS-Generator ohne Abhängigkeiten

Speichere dies als scripts/generate-rss.mjs und starte 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: "RSS mit Claude Code implementieren",
    description: "RSS 2.0 für eine statische Site erzeugen und validieren.",
    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(`/de/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 Deutsch</title>
    <link>${siteUrl}/de/</link>
    <description>Praxisguides für Claude Code</description>
    <language>de</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}`);

Wichtig sind escapeXml(), new URL() und Datumsprüfung. Diese Guards dürfen bei einem Claude-Code-Refactoring nicht verschwinden.

Astro-Implementierung

Astro bietet @astrojs/rss.

npm install @astrojs/rss

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

  return rss({
    title: "ClaudeCodeLab Deutsch",
    description: "Praxisguides für Claude Code",
    site: context.site,
    items,
    customData: "<language>de</language><ttl>60</ttl>",
  });
}

Discovery Links im head:

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

Atom, Mehrsprachigkeit und Validierung

Atom braucht stabile id-Werte und ISO-Daten.

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

Mehrsprachige Konfiguration:

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

Lokaler Check:

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

Typische Fehler: R&D ohne Escaping, Drafts im Feed, relative URLs, unklare Daten, deutscher Feed mit englischen Links, zu langer CDN-Cache.

Prompt und Praxistest

Implementiere RSS 2.0 für diese Astro-Site.
- Bearbeite nur src/pages/de/rss.xml.ts.
- Nutze @astrojs/rss.
- Schließe Drafts aus.
- Sortiere nach updatedDate oder pubDate, neueste zuerst.
- Begrenze auf 30 Artikel.
- Nutze den Prefix /de/blog/.
- Ergänze language und ttl.
- Berichte Befehle und Validierung.

Prüfe die RSS-Implementierung kritisch.
Priorisiere XML-Escaping, relative URLs, Draft-Leaks, Datumsformat, stabile guid, Sprachprefixe, Cache und W3C-Validierung.

Ich habe den Ablauf mit einem kleinen Astro-Datensatz getestet. Das lokale Script fand ein nicht escaptes & und eine nicht absolute guid, bevor der Browser geöffnet wurde. Menschlich geprüft werden mussten Übersetzung, CTA und Anzeige in einem echten Reader. Für Teams, die RSS, Sitemap, Artikel-QA und Conversion verbinden möchten, passt Claude Code Training und Beratung.