Introduction
In July 2026, a developer published a detailed case study on Habr describing a frustrating journey with building a news aggregator. The key insight? The project only started delivering reliable, useful results after the creator stopped blindly relying on AI-generated summaries and classification. This article examines the technical and practical lessons from that experience, offering a roadmap for anyone building their own news aggregation tool.
The original article, titled "Агрегатор новостей заработал, когда я перестал доверять ИИ" (The news aggregator worked when I stopped trusting AI), chronicles months of trial and error. The developer initially used large language models (LLMs) to automatically summarize and categorize news from multiple RSS feeds. Despite impressive demos, the system consistently produced irrelevant, outdated, or outright incorrect content. Only after implementing a hybrid approach — combining traditional keyword extraction, user-defined filters, and limited AI assistance — did the aggregator become genuinely useful.
The Problem with AI-Only Aggregation
Many developers assume that feeding a dozen RSS feeds into an LLM API will magically produce a perfect news digest. The reality, as described in the case study, is more complex. The AI model frequently:
- Generated hallucinated summaries: It invented quotes and statistics that never appeared in the original articles.
- Missed context: Important regional or industry-specific nuances were lost, making summaries misleading.
- Failed on timeliness: The model sometimes summarized older articles as if they were breaking news, confusing readers.
- Produced generic output: Without explicit instructions, the AI defaulted to bland, uninformative summaries that added no value.
The developer noted that these issues persisted even with fine-tuned prompts and temperature adjustments. The root cause was not the model itself, but the assumption that AI could replace human judgment in curating news.
The Hybrid Approach That Worked
After months of frustration, the developer redesigned the aggregator around three core principles:
1. Rule-Based Filtering First
Instead of letting AI decide what was important, the system applied deterministic rules:
- Keyword matching: Users defined keywords (e.g., "Python", "startup funding", "climate policy") and only articles containing those terms were processed.
- Source whitelisting: Only trusted feeds from specific domains were allowed — no automatic discovery.
- Date filtering: Articles older than 48 hours were automatically excluded from the "breaking" category.
2. AI as a Secondary Tool
AI was reserved for two specific tasks:
- Summarization of filtered articles: Only after an article passed the rule-based checks was it sent to an LLM for a short summary (max 2 sentences).
- Deduplication: The model identified near-duplicate articles from different sources and merged them, keeping the most authoritative version.
3. Human-in-the-Loop Feedback
The developer implemented a simple feedback mechanism: users could upvote or downvote summaries, and the system learned from these signals. Over time, the AI's output improved for each individual user.
Practical Implementation Steps
If you want to build a similar system, here are the concrete steps based on the case study:
| Step | Action | Example Tool/Approach |
|---|---|---|
| 1 | Select RSS feeds manually | Choose 10-20 high-quality sources per topic |
| 2 | Define keyword filters | Use Python's re module for regex matching |
| 3 | Build a deduplication module | Compare article titles with Levenshtein distance |
| 4 | Integrate AI summarization | Use OpenAI API or local model (e.g., Llama 3) with strict prompt |
| 5 | Add feedback collection | Simple thumbs-up/thumbs-down button per summary |
| 6 | Schedule periodic updates | Use cron job or AWS Lambda (every 30 minutes) |
Code Example: Keyword Filtering
import feedparser
import re
KEYWORDS = ["AI", "machine learning", "neural network"]
def filter_articles(feed_url):
feed = feedparser.parse(feed_url)
relevant = []
for entry in feed.entries:
text = entry.title + " " + entry.summary
if any(re.search(kw, text, re.IGNORECASE) for kw in KEYWORDS):
relevant.append(entry)
return relevant
Why Trusting AI Alone Fails
The case study highlights a broader lesson: AI excels at generating plausible-sounding text, but it lacks genuine understanding of relevance, timeliness, and authority. For news aggregation, these qualities are critical. A user reading about "latest breakthroughs in quantum computing" expects recent, verified information — not a model's best guess at what might be interesting.
Moreover, AI models are trained on static datasets and cannot distinguish between a reputable journal and a rumor mill. Without explicit source curation, the aggregator becomes a noise machine.
Results After the Change
After implementing the hybrid system, the developer reported:
- 80% reduction in irrelevant articles reaching users.
- Significant improvement in user satisfaction (measured by return visits).
- Lower API costs: AI calls dropped by 60% because only filtered articles were processed.
- Faster performance: Rule-based filtering runs in milliseconds, while AI calls took seconds.
Conclusion
The story of this news aggregator is a cautionary tale for anyone tempted to throw AI at every problem. The developer succeeded not by rejecting AI, but by putting it in its proper place: as a helper, not a decision-maker. For projects involving curation, recommendation, or summarization, a hybrid architecture — combining deterministic rules with selective AI — consistently outperforms pure AI approaches.
If you are building a similar tool, start with the simplest possible filters and add AI only where it demonstrably improves the output. Your users will thank you, and your server bills will stay low.
Comments