Last30Days Skill Review 2026: Fresh Data for Claude

What Last30Days Skill Does

Last30Days is an agent skill, not a standalone app. It targets Claude Code and the broader Agent Skills format: a directory with a SKILL.md manifest that tells the agent when to invoke it and what to do. The repository at github.com/mvanhorn/last30days-skill shows 65,689 stars as of this writing, which is a lot of attention for a skill that does one narrow thing.

That one thing: pull recent web signal on a topic and hand it back to the agent so answers stop leaning on training data that ended months ago. The description on the repo says it researches a topic across Reddit, X, YouTube, Hacker News and the web, then synthesizes a source-grounded summary. The manifest declares the trigger conditions and the tool calls; the skill itself is mostly orchestration around those sources.

Output format matters here. The skill returns a synthesized summary with sources attached, not a raw dump of links. That is the useful part for an agent: the model gets prose it can reason over plus citations it can check, instead of a wall of URLs it has to fetch and parse itself.

I would frame the value proposition narrowly. If your agent already has a web search tool, Last30Days is not adding a new capability so much as a recency filter and a multi-source fan-out on top of one. Whether that filter holds is the whole question, and it is answerable with dates rather than impressions.

Install and first run in 2026

The install path follows the standard Agent Skills convention. You place the skill directory where Claude Code looks for skills, typically under a .claude/skills/ folder in your project or the user-level equivalent, and the agent picks up SKILL.md from there. The repository README is the source of truth for the exact path and any per-source setup, and I would read it before assuming the layout matches another skill you installed.

API keys are the friction point. The skill fans out to Reddit, X, YouTube and Hacker News, and those sources do not all answer anonymous requests at volume. Expect to provision credentials for at least some of them. The manifest and README describe which sources need keys and which work without. Skipping a key does not usually break the skill; it quietly narrows the source set, which is worse because you may not notice the gap until an answer cites only two platforms.

A sample prompt looks like anything you would already type: "what are people saying about X in the last month" or "summarize recent discussion of Y." The skill triggers on the recency intent. Expected output is a short synthesized brief with dated sources, not a list.

Failure modes worth knowing before you install:

• Missing keys silently reduce coverage rather than erroring.
• Rate-limited sources return partial results, and the summary may not flag the gap.
• Topics with thin recent discussion produce a confident-sounding summary built on very few items.
• If the agent decides the skill does not apply, you get a plain answer with no recency guarantee and no warning that the skill was skipped.

That last one is the sneakiest. Skill triggering is a model decision, and a model that misjudges intent will answer from memory while you assume fresh data went in.

How it ranks recency

The pipeline the repository describes is fetch, dedupe, date filter, rank. Each stage is where freshness either survives or leaks.

Fetch is a fan-out across the five source types. Reddit and Hacker News give you discussion threads with timestamps. X gives you posts, subject to API tier limits. YouTube gives you video metadata and descriptions, which are dated but not always informative about content. The open web fills gaps. Coverage is broad across platforms but shallow within each: this is not a crawler that indexes everything, it queries what the APIs expose.

Dedupe matters more than it sounds. The same story surfaces on Hacker News, gets posted to Reddit, gets a YouTube reaction, and shows up in a blog post. Without dedupe the ranking stage sees four signals where there is one event, and a single piece of news looks like a trend. The repository describes deduplication as part of the pipeline; how aggressive it is determines whether you get breadth or an echo.

The date filter is the load-bearing step. "Last 30 days" is easy to state and hard to enforce when sources report dates inconsistently. Reddit has creation timestamps. Hacker News has them. YouTube has upload dates that may not match when the content became relevant. Blog posts have publish dates that are sometimes wrong, sometimes absent, sometimes updated without changing the original date. Every one of those is a place where an item older than the cutoff slips through, or a fresh item gets dropped because its date could not be parsed.

Ranking then orders what survives. Recency is one input; engagement and source authority are others. A 28-day-old thread with heavy discussion can outrank a 2-day-old post nobody saw, which is defensible but means the output is not strictly chronological. If you need strict chronology, this is not that tool.

Where cutoffs slip, in my reading of how these pipelines usually fail: items with missing dates get included by default or excluded by default, and neither choice is obviously right. Items dated by update rather than creation look fresher than they are. Cross-posted content carries the date of the repost. None of these are unique to Last30Days, but they are the reasons a "last 30 days" claim needs checking against the actual dates in the output rather than trusted.

Benchmark: freshness versus vanilla web search

The honest way to evaluate a recency tool is to count dates. Take a fixed set of queries, run them through the skill and through plain web search, and score the cited items by whether their dates fall inside 30 days. I have not run that benchmark, and I will not invent numbers for it. What I can give you is the method and what each outcome would mean, so you can run it yourself in an afternoon.

The scoring dimensions:

• Freshness rate: share of cited items whose dates fall within 30 days of the run. Count from the output, not from the summary's claims about itself.
• Stale-claim rate: share of factual assertions in the summary that trace to a source older than the cutoff, or to no source at all.
• Latency: wall-clock time per query, skill versus plain search. Multi-source fan-out costs time; the question is whether the delay is seconds or minutes.
• Token cost per run: input and output tokens consumed by the synthesis step, priced against whatever model you route it through.

Ten queries is enough to see a pattern if you pick them deliberately: three fast-moving topics (AI releases, a live news event, a product launch), three slow-moving (a mature library, a policy question, a scientific topic), two evergreen (how to write a for-loop, what HTTP is), and two where you already know the answer so you can spot errors.

My expectation, stated as expectation and not result: the skill wins clearly on fast-moving topics, ties or loses slightly on slow-moving ones because plain search is cheaper when recency does not matter, and adds nothing on evergreen queries where the best answer has not changed in years. The stale-claim rate is where I would watch hardest, because a synthesized summary can sound current while resting on old sources, and that failure is invisible unless you check the dates.

If you run this, score the dates mechanically. Read the summary last. A summary that reads well biases you toward trusting its sources, which is exactly the failure mode a recency tool is supposed to prevent.

Cost and rate limits

The skill itself is free. The repository lists no price, and the tool's starting price is $0/mo. What costs money is everything around it: the model tokens for synthesis, and any API tiers for the sources that require them.

Token spend per run depends on how much source material the skill pulls in before synthesizing. A five-source fan-out on a busy topic can mean a lot of input tokens. Priced against current models, the range is wide. At the low end, a mid-tier model handles synthesis cheaply. At the high end, routing synthesis through something like claude-opus-4.7-fast at $30/M input and $150/M output, or gpt-5.5-pro at $30/M input and $180/M output, turns a chatty source pull into real money per query. For a research agent running dozens of queries a day, that adds up fast. For occasional use, it is noise.

The practical move is to route synthesis to a cheaper model and reserve the expensive ones for queries where the answer matters. The skill does not force a model choice; that is your configuration.

Rate limits are the other cost, paid in failures rather than dollars. X's API is the usual bottleneck, with tier limits that throttle at volume. Reddit throttles unauthenticated requests. At low volume you will not notice. At agent scale, where a single task might trigger several research calls, you will hit ceilings and get partial results. The skill's behavior under throttling, whether it retries, degrades, or returns what it has, is described in the repository and worth reading before you build a workflow that depends on complete coverage.

Limits

Source bias is structural. Reddit, X, YouTube and Hacker News over-represent technical, English-speaking, extremely online audiences. A question about enterprise procurement, local regulation, or non-English markets will get a skewed picture, and the summary will not necessarily tell you the sample is skewed. It reports what it found; it does not audit who it did not hear from.

Paywalled and subscription news are largely absent. The skill works from what the APIs and open web expose, and a lot of the most reliable reporting sits behind paywalls. That pushes coverage toward aggregators, blogs and social discussion, which is faster but less verified. For breaking news, that trade is fine. For anything where accuracy matters more than speed, it is a real gap.

Evergreen topics are the clearest miss. Ask about the last 30 days of discussion on a stable topic and you get either nothing or a thin slice of noise that happens to be recent. The skill cannot tell you that the last 30 days contain no signal; it will synthesize whatever it found. A model that knows when to say "nothing recent, here is the stable answer" would be better, and that judgment is not something a fetch-and-summarize pipeline provides.

There is also the triggering problem from earlier. The skill only helps when the agent invokes it, and invocation is a model decision. In a long session the agent may drift toward answering from context and skip the skill entirely. If recency is critical, you want an explicit instruction in your prompt or system context, not reliance on the model to notice.

Verdict: who should install it

Install it if your agent does research where the answer changes month to month: competitive landscape questions, "what are people saying about" prompts, tracking a fast-moving field, monitoring a topic you care about. The multi-source fan-out and the dated synthesis are genuinely more than a single search call gives you, and the 65,689 stars suggest a lot of people found the same gap.

Skip it if your workflow is code-only. An agent writing, refactoring and debugging code does not need last-30-day web signal, and adding a skill that can trigger on research-shaped prompts adds latency and token cost for no benefit. Also skip if you need strict chronological ordering, verified news sources, or coverage of non-English or paywalled material. And skip if you are not prepared to check the dates in the output, because the whole value depends on them being right.

For teams already running Claude Code with a skill setup, the install cost is low and the downside is bounded. For anyone building a research pipeline where freshness is a hard requirement, treat the skill as one input among several and verify the dates rather than trusting the label.

Beetlix is our own product. Where Last30Days pulls recent web signal into an agent's context, Beetlix focuses on the agent workflow around it; if you are comparing research-oriented setups, beetlix.com is the place to look. The two are not substitutes, and I would not frame one as replacing the other.

Score card

• Freshness design: 8/10. Multi-source fan-out with a date filter is the right architecture; enforcement is where it can slip.
• Install friction: 7/10. Standard skill layout, but per-source API keys are real setup work.
• Cost efficiency: 7/10. Free skill, but synthesis tokens and source API tiers are yours to manage.
• Coverage: 6/10. Broad across platforms, thin within each, and structurally biased toward technical English discussion.
• Transparency: 7/10. Sources are attached; whether gaps are flagged is the open question.
• Overall: 7.0/10.

How this review was researched

This review draws on the repository at github.com/mvanhorn/last30days-skill, including its star count and the SKILL.md manifest, the vendor documentation and README describing the fetch and synthesis pipeline, the official pricing page (which lists the skill at $0/mo), and live model pricing data for the token-cost discussion. No hands-on run was performed; the benchmark section describes a method and expected outcomes, not measured results. Where the repository does not state a behavior, this review says so rather than filling the gap.