/blogwatcher

name: blogwatcher
description: Monitor and summarize blog posts, RSS feeds, and web content for research and staying current with topics.
version: 1.0.0
author: hermes-CCC (ported from Hermes Agent by NousResearch)
license: MIT
metadata:
  hermes:
    tags: [Research, RSS, Blogs, Monitoring, Summarization]
    related_skills: []

Blogwatcher

Purpose

• Use this skill to monitor RSS feeds and blog-style content for ongoing research.
• It is useful for staying current on AI, ML, engineering, and product ecosystems.
• Prefer RSS when you want structured updates without scraping full websites every time.

Install

pip install feedparser

Parse a Feed

import feedparser

feed = feedparser.parse("https://example.com/rss")
print(feed.feed.title)
print(feed.entries[0].title)

• `feedparser` handles RSS and Atom feeds.
• The parsed object exposes feed metadata and a list of entries.

Access Entry Fields

entry = feed.entries[0]
print(entry.title)
print(entry.summary)
print(entry.link)
print(entry.published)

• The most commonly useful fields are `.title`, `.summary`, `.link`, and `.published`.
• Not every feed includes every field, so code defensively.

Batch Fetch Multiple Feeds

import feedparser

feeds = [
    "https://example.com/rss",
    "https://another.example/feed.xml",
]

all_entries = []
for url in feeds:
    parsed = feedparser.parse(url)
    for entry in parsed.entries:
        all_entries.append(
            {
                "source": parsed.feed.get("title", url),
                "title": entry.get("title", ""),
                "summary": entry.get("summary", ""),
                "link": entry.get("link", ""),
                "published": entry.get("published", ""),
            }
        )

• Batch fetches are the standard pattern for topic monitoring.
• Normalize fields early so downstream summarization stays simple.

Filter by Date or Keyword

• Filter by date when you only care about the most recent week or month.
• Filter by keyword when watching narrow topics like `agents`, `evals`, or `multimodal`.
• Keep the filter stage simple and deterministic.

Example:

keywords = ["llm", "agents", "retrieval"]
filtered = [
    e for e in all_entries
    if any(k.lower() in (e["title"] + " " + e["summary"]).lower() for k in keywords)
]

Summarize With Claude

• Extract the title and summary from each entry.
• Feed the collected set into Claude and ask for synthesis by theme, signal, and novelty.
• This works better than summarizing one feed item at a time when you are tracking a field.

Example prompt shape:

Summarize these AI research updates. Group them into model releases, tooling, benchmarks, and policy. Highlight what appears genuinely new.

• Keep the raw title, summary, link, and publication date in the source material.
• Ask for a synthesis, not a rewrite.

Save Results to a File

import json

with open("feed_digest.json", "w", encoding="utf-8") as f:
    json.dump(filtered, f, ensure_ascii=False, indent=2)

• Save structured digests for later comparison.
• JSON is the easiest format for later reprocessing.
• Markdown is convenient if the output is intended for direct reading.

Common AI and ML Blogs To Monitor

• arXiv Sanity
• Hugging Face Blog
• OpenAI
• Anthropic
• engineering blogs from inference providers, vector DB vendors, and cloud platforms

• Some sources are better via RSS.
• Others may require periodic scraping or newsletter ingestion.

Combine With `/arxiv`

• Use this skill for blog and announcement monitoring.
• Combine it with `/arxiv` for paper discovery and academic monitoring.
• The combination gives better coverage across research papers, product launches, and engineering writeups.

Good Monitoring Workflow

1. Define a small set of feeds by topic. 2. Fetch them on a schedule. 3. Normalize fields into one list. 4. Filter by keyword and freshness. 5. Ask Claude to synthesize the daily or weekly signal. 6. Save the resulting digest for later reference.

Practical Notes

• RSS coverage varies widely by site.
• Feed summaries are often enough for triage but not enough for deep analysis.
• Follow links for the few items that survive filtering.
• Save source links alongside the synthesis so claims remain traceable.

Summary

• Install RSS parsing support with `pip install feedparser`.
• Parse feeds with `feedparser.parse("https://example.com/rss")`.
• Access fields like `feed.entries[0].title`, `.summary`, `.link`, and `.published`.
• Batch fetch multiple feeds, then filter by date or keyword.
• Summarize title and summary pairs with Claude for cross-source synthesis.
• Save digests to a file and combine this workflow with `/arxiv` for broader research monitoring.