aifeed.fyi - AI news today

5 March 2026

Ai Top News

Hardware

Applications

/r/ClaudeAI

I had Opus 4.6 evaluate 547 Reddit investing recommendations on reasoning quality with no upvote counts, no popularity signals. Its filtered picks returned +37% vs the S&P's +19%.

Hi everyone,

A couple weeks back, I ran an experiment where[ I fed 48 years of Buffett's shareholder letters to Claude Opus 4.6](https://www.reddit.com/r/ClaudeAI/comments/1rhbhoq/i_fed_opus_46_all_48_of_warren_buffetts/) and had it pick stocks blind (it matched 6 out of 10 Berkshire holdings without knowing what it was looking at). That experiment got a lot of great feedback and one of the most common requests was to test AI on real Reddit stock advice instead of just Buffett's principles.

I used Claude Code to build a multi-agent pipeline that grabs investing recommendations from r/ValueInvesting subreddit for the month of Feb 2025, strip popularity signals, and have Claude sub-agents score each investing recommendation blind on reasoning quality alone. Then I built three portfolios (10 stocks per portfolio):

* **The Crowd**: top 10 stocks ranked by total upvotes across all mentions
* **Claude's Picks**: top 10 stocks ranked by reasoning quality score
* **The Underdogs**: bottom 10 stocks by upvotes (min 5 upvotes), to test whether the crowd was right to ignore them

I tracked their real returns over a year from Feb 2025 - Feb 2026.

The part I found most interesting was that on data completely outside Opus's training window (Sep 2025 onward), Claude's picks returned +5.2% vs the most upvoted stocks only -10.8% (S&P 2%).

If you prefer to watch the full experiment, I uploaded it to my channel:[ https://www.youtube.com/watch?v=tr-k9jMS\_Vc](https://www.youtube.com/watch?v=tr-k9jMS_Vc) (free).

**The Setup**

I used Claude Code to scrape every single post from [r/ValueInvesting](https://www.reddit.com/r/ValueInvesting/) for the month of February 2025 and filter down to posts and comments where someone was recommending, analyzing, or debating a specific stock. This gave me 1,100+ qualifying threads, 6,000+ comments, and 547 individual stock recommendations across 238 unique tickers.

I then had Opus score every single one on five dimensions: thesis clarity, risk acknowledgment, data quality, specificity, and original thinking.

From there I built the three portfolios of **The Crowd**, **Claude's Picks**, **The Underdogs**.

All portfolios were equal-weight, bought on March 3, 2025 (first trading day of March). They had the same entry, same exit, with no cherry-picking.

Following was my Claude Code setup:

  reddit-stock-analysis/
    ├── orchestrator # Main controller - runs full pipeline per month
    ├── skills/
    │ ├── scrape-subreddit # Pulls all posts + comments for a given month via Reddit API
    │ ├── filter-recommendations # Identifies posts where someone recommends/analyzes a stock
    │ ├── extract-tickers # Maps mentions → ticker symbols, deduplicates
    │ ├── strip-popularity # Removes upvote counts, awards, author karma
    │ ├── build-portfolios # Constructs Crowd (by upvotes) vs AI (by score) vs Underdog
    │ └── track-returns # Looks up actual price returns for each portfolio
    └── sub-agents/
        └── (spawned per recommendation) # Blind scoring - no popularity signals, just the post text
            ├── thesis-clarity # Is there a structured argument for why this stock?
            ├── risk-acknowledgment # Does the post address what could go wrong?
            ├── data-quality # Real financials (P/E, margins, debt) or just vibes?
            ├── specificity # Concrete targets, timeframes, catalysts?
            └── original-thinking # Independent analysis or echoing the crowd?

**The Blind Test (Sep 2025 – Feb 2026)**

Before I share the main backtest, I want to start with the result I think matters more.

One fair criticism that keeps coming up in these experiments is that the AI might have seen these stock prices during training. The model I used has a training cutoff of August 2025, so the February recommendations do fall within that window. Even though the AI was only scoring argument quality (not predicting prices), it could theoretically recognize which stocks were being discussed.

So I reran the entire experiment on September 2025 recommendations, which is completely outside the model's training data. It resulted in over 800 threads, 10,500 comments, 2,200 recommendations scored. This guaranteed that the model did not have any knowledge of the stock price movement during this time in its training data.

AI: +5.2%
S&P 500: +2.4%
Crowd: -10.8%

On data the AI couldn't have possibly seen, it still beat the market. The crowd portfolio went negative. I think this is the cleanest result from the experiment because there's no way to argue the AI was cheating.

**The Full Backtest (Feb 2025 – Feb 2026)**

Now here's the full year backtest on the February data:

The Crowd: +39.8% (+20.3% vs S&P)
AI's Picks: +37.0% (+17.5% vs S&P)
S&P 500: +19.5%
Underdogs: +10.4% (-9.1% vs S&P)

The crowd actually won by about 3 percentage points. Both beast the S&P. But when I looked at the individual stocks, the story got a lot more interesting. AI's portfolio had 9 out of 10 winners. The worst performer was OSCR at -12%.

Both portfolios ended up in a similar place but the crowd went from +39.8% to -10.8% across the two time periods which feels quite inconsistent while Opus-filtered recommendations managed to gain both times.

**What I took away from this**

I don't think the takeaway is necessarily that "Opus picks better stocks." It's more that Opus appears to be better at telling apart solid analysis from stuff that just sounds good. It might serve as a good tool to filter out advice posts here down to solid ones that do good due diligence. The most popular advice and the best-reasoned advice had almost nothing to do with each other.

If this was interesting to you the full walkthrough is here including all the data:[ https://www.youtube.com/watch?v=tr-k9jMS\_Vc](https://www.youtube.com/watch?v=tr-k9jMS_Vc) (free)

Thank you so much if you did end up reading this far. Would love to hear if you have been experimenting similarly with Claude, let me know :-).

--- TOP COMMENTS ---
Have you calculated the statistical significance of the result?

What does the distribution of outcomes look like for a random strategy?

---

Methodology:
∙ How were ties handled in the scoring? When multiple sub-agents scored the same recommendation, what was the aggregation method — average, weighted, majority?
∙ Did any single stock dominate either portfolio’s returns? With 10-stock equal-weight portfolios, one outlier (positive or negative) can tell most of the story.
∙ What happened to the Underdogs portfolio in the Sep 2025 blind test? That comparison feels like the missing piece.

On the scoring dimensions:
∙ Were the five dimensions weighted equally? “Original thinking” and “data quality” feel like they should carry more weight than “specificity” if the goal is finding genuinely good analysis.
∙ Did high-scoring posts cluster around any particular sectors, or was it spread across the market?
On replication:
∙ Has anyone tried running the same pipeline on a different subreddit (r/stocks, r/investing) to see if the gap between crowd and reasoning-quality picks holds?
∙ What does the score distribution look like? Were most recommendations clustered in the middle, or was there a clear separation between high and low scorers?
The question I’m most curious about:
∙ Of the posts that scored high on reasoning quality but got almost no upvotes — what did they have in common stylistically? My guess is they were longer, more hedged, and less exciting to read. That would really nail down why popularity and quality diverge.
What did the data actually show on that last one?..

8h ago

/r/ClaudeAI

I used Claude to create a simple local hook that cut my AI costs by 50-70%

I use Claude AI models in Cursor. One of my good buddies uses Claude Code. We were both facing the same issue: leaving the model set to the most expensive option and never touching it again.

I built this for Cursor, and in principle it should work the same in Claude Code (both use the same hook system). Anyone here tried this in Claude Code yet?

I pulled a few weeks of my own prompts and found:

* \~60–70% were standard feature work Sonnet could handle just fine
* 5–20% were debugging/troubleshooting
* a big chunk were pure git / rename / formatting tasks that Haiku handles identically at 90% less cost

The problem is not knowledge; we all know we should switch models. The problem is friction. When you are in flow, you do not want to think about the dropdown.

So I wrote a small local hook that runs before each prompt is sent in Cursor/Claude Code. It sits next to Opus/plan; think of it as an efficient front-end filter that stops the obviously bad matches before they ever hit Opus.

I figure, most people want to create more within their budget, this makes it so they might spend the same amount but ship more with less.

**It:**

* reads the prompt + current model
* uses simple keyword rules to classify the task (git ops, feature work, architecture / deep analysis)
* blocks if I am obviously overpaying (e.g. Opus for git commit) and suggests Haiku/Sonnet
* blocks if I am underpowered (Sonnet/Haiku for architecture) and suggests Opus
* lets everything else through
* ! prefix bypasses it completely if I disagree

**It is:**

* 3 files (bash + python3 + JSON)
* no proxy, no API calls, no external services
* fail-open: if it hangs, Claude Code just proceeds normally

On a retroactive analysis of my prompts it would have cut \~50–70% of my AI spend with no drop in quality, and it got 12/12 real test prompts right after a bit of tuning.

I open-sourced it here if anyone wants to use or improve it:

[https://github.com/coyvalyss1/model-matchmaker](https://github.com/coyvalyss1/model-matchmaker)

I am mostly curious what other people's breakdown looks like once you run it on your own usage. Do you see the same "Opus for git commit" pattern, or something different?

Thanks!

--- TOP COMMENTS ---
How does this effect your cache hit for you context? Eg. If you swap models at the end for the git work, you either use a sub agent on the cheaper model with a very smaller/fresh context, or you have to feed in the full context to get it to continue in the new cheaper model session.

Still trying to figure this balance out myself. There was a great video about all the work Claude does this to save money automatically and use cheaper models on the explore phases in planning mode, etc.

---

Nice approach. One thing that helped me with the cache/context tradeoff is splitting execution tasks into cheap sub-agents with a tiny task brief plus explicit artifacts (files changed, commands run, outputs), then only escalating back to Opus when architecture-level decisions show up. If a “cheap” branch keeps needing full context, I treat that as a sign it wasn’t actually cheap work and keep it in the main thread. Curious if you’ve tried a threshold (token delta or number of files touched) to decide model switches...

18h ago

Tools

Open Source

/r/LocalLLaMA

Qwen3.5-35B-A3B hits 37.8% on SWE-bench Verified Hard — nearly matching Claude Opus 4.6 (40%) with the right verification strategy

[Qwen3.5-35B-A3B hits 37.8% on SWE-bench Verified Hard](https://preview.redd.it/ecvh8rwhxymg1.png?width=2081&format=png&auto=webp&s=ac79a8173c4b0f781749d23f404c1d73e989009a)

[cumulative resolution vs steps](https://preview.redd.it/f31egqjkxymg1.png?width=1773&format=png&auto=webp&s=41ee70bec949634a2f162a376f1f1532c3b8fe39)

I've been running experiments on SWE-bench Verified with a tiny MoE model (Qwen3.5-35B-A3B, only 3B active params) self-hosted via vLLM, and the results surprised me.

TL;DR: By adding a simple "verify after every edit" nudge to the agent loop, a 3B-active model goes from 22% → 38% on the hardest SWE-bench tasks, nearly matching Claude Opus 4.6's 40%. On the full 500-task benchmark, it hits 67.0% — which would put it in the ballpark of much larger systems on the official leaderboard.

**What I tried**

I build a minimal agent harness (tools : `file_read`, `file_edit`, `bash`, `grep` , `glob`) and iterated on verification strategies :

|Strategy|Hard (45 tasks)|Full (500 tasks)|
|:-|:-|:-|
|agent-harness (baseline, no self-verification)|22.2%|64%|
|verify-at-last (write test script before declaring done)|33.3%|67%|
|verify-on-edit (force agent to test after every `file_edit`)|37.8%|\-|
|Claude Opus 4.6 (for reference) |40.0%||

The "verify-on-edit" strategy is dead simple — after every successful file\_edit, I inject a user message like:

"You just edited X. Before moving on, verify the change is correct: write a short inline python -c or a /tmp test script that exercises the changed code path, run it with bash, and confirm the output is as expected."

That's it. No fancy search algorithms, no reward models, no multi-agent setups. Just telling the model to check its work after every edit.

**what didn't work**

* MCTS / tree search: Tried multiple variants, all performed worse than the straight-line baseline. Verifier scores didn't correlate with actual resolution. Tree search breaks the coherent reasoning flow that small models need.
* \- Best-of-N sampling: Some marginal gains but not worth the compute.

**Code + configs + all experiment logs:** [**github.com/SeungyounShin/agent-verify**](http://github.com/SeungyounShin/agent-verify)

--- TOP COMMENTS ---
My suggestion would be to wait till swe-rebench has enough new tasks and re-run your evals. The problem with swebench is that it is old, and models released now can have leaked signals in their training data.

---

Sorry but this cannot be true. Clearly benchmaxed. Even the 3.5 397B deleted multiple files without asking in opencode yesterday...

22h ago

/r/LocalLLaMA

Qwen3.5-27B Q4 Quantization Comparison

This is a Q4 quantization sweep across all major community gguf quants of Qwen3.5-27B (available the 03/03/2026), comparing mean KLD to the BF16 baseline across different quantizers and recipes.

The goal is to give people a data-driven basis for picking a file rather than just grabbing whatever is available.

KLD (KL Divergence): "Faithfulness." It shows how much the quantized model's probability distribution drifts from the probability distribution of the original weights. Lower = closer.

# KLD Results — Custom Chat Dataset

Evaluated on `titwitMuffbiscuit-v03-full.txt` — chat-wrapped corpus (Qwen3.5 ChatML format), 47 chunks -c 4096. Content: Science & engineering, Medicine, Philosophy, History, Finance, Culture, multilingual content and code snippets.

[lmstudio-community and mradermacher standard Q4\_K\_M are identical — stacking on the plot.](https://preview.redd.it/kf39ily54xmg1.png?width=2979&format=png&auto=webp&s=00a054c35288ad2f62e4f0ecb1d406787a7d0a42)

# Wikitext2 + Custom Dataset Comparison

Evaluated on `wikitext2_test.txt`, 72 chunks -c 4096. Content: plain text english.
The dumbbell plot shows both datasets side by side.

[lmstudio-community and mradermacher standard Q4\_K\_M are identical — blending visible on the dumbbell plot.](https://preview.redd.it/o7xdrxt74xmg1.png?width=2979&format=png&auto=webp&s=e78996249dea09f8647141c1fc52f547678ff066)

# Sorted by KLD — Custom Dataset

|Rank|Quantization|Size (GiB)|PPL|KLD|
|:-|:-|:-|:-|:-|
|1|unsloth\_Qwen3.5-27B-UD-Q4\_K\_XL|16.411|5.8901|0.005087|
|2|bartowski\_Qwen3.5-27B-Q4\_K\_M|15.952|5.8882|0.005633|
|3|unsloth\_Qwen3.5-27B-Q4\_K\_M|15.591|5.8948|0.006193|
|4|ubergarm\_Qwen3.5-27B-smol-IQ4\_NL|15.415|5.9026|0.006371|
|5|mradermacher\_Qwen3.5-27B.i1-Q4\_K\_M|15.404|5.9059|0.006469|
|6|bartowski\_Qwen3.5-27B-Q4\_K\_S|14.985|5.8984|0.006720|
|7|bartowski\_Qwen3.5-27B-IQ4\_XS|14.130|5.9017|0.007062|
|8|bartowski\_Qwen3.5-27B-IQ4\_NL|14.851|5.9091|0.007233|
|9|unsloth\_Qwen3.5-27B-Q4\_K\_S|14.686|5.9083|0.007449|
|10|unsloth\_Qwen3.5-27B-IQ4\_NL|14.610|5.9147|0.007461|
|11|mradermacher\_Qwen3.5-27B.i1-IQ4\_XS|13.680|5.9129|0.007569|
|12|unsloth\_Qwen3.5-27B-IQ4\_XS|13.949|5.9179|0.007677|
|13|mradermacher\_Qwen3.5-27B.i1-Q4\_K\_S|14.499|5.9209|0.007937|
|14|mradermacher\_Qwen3.5-27B.Q4\_K\_M|15.404|5.9028|0.009201|
|15|mradermacher\_Qwen3.5-27B.IQ4\_XS|13.784|5.9342|0.011463|
|16|steampunque\_Qwen3.5-27B.Q4\_K\_H|14.864|5.9050|0.012091|
|17|mradermacher\_Qwen3.5-27B.Q4\_K\_S|14.499|5.9293|0.012364|

*lmstudio-community Q4\_K\_M excluded — identical file to mradermacher Q4\_K\_M.*

# Most Efficient Quantization — Custom Dataset

The Efficiency Score is the distance to a 'perfect' model (zero size, zero KLD), not the 'best' model but the VRAM sweet spot.

Efficiency Score: √ (Normalized Size² + Normalized KLD²) — lower is better.

|Rank|Quantization|Size (GiB)|KLD|Eff. Score|
|:-|:-|:-|:-|:-|
|1|bartowski\_Qwen3.5-27B-IQ4\_XS|14.130|0.007062|0.317506|
|2|mradermacher\_Qwen3.5-27B.i1-IQ4\_XS|13.680|0.007569|0.341075|
|3|unsloth\_Qwen3.5-27B-IQ4\_XS|13.949|0.007677|0.369294|
|4|unsloth\_Qwen3.5-27B-IQ4\_NL|14.610|0.007461|0.471585|
|5|unsloth\_Qwen3.5-27B-Q4\_K\_S|14.686|0.007449|0.490965|
|6|mradermacher\_Qwen3.5-27B.i1-Q4\_K\_S|14.499|0.007937|0.493275|
|7|bartowski\_Qwen3.5-27B-IQ4\_NL|14.851|0.007233|0.520404|
|8|bartowski\_Qwen3.5-27B-Q4\_K\_S|14.985|0.006720|0.527916|
|9|mradermacher\_Qwen3.5-27B.i1-Q4\_K\_M|15.404|0.006469|0.659219|
|10|ubergarm\_Qwen3.5-27B-smol-IQ4\_NL|15.415|0.006371|0.659346|
|11|unsloth\_Qwen3.5-27B-Q4\_K\_M|15.591|0.006193|0.716059|
|12|bartowski\_Qwen3.5-27B-Q4\_K\_M|15.952|0.005633|0.835306|
|13|mradermacher\_Qwen3.5-27B.Q4\_K\_M|15.404|0.009201|0.847417|
|14|mradermacher\_Qwen3.5-27B.IQ4\_XS|13.784|0.011463|0.877012|
|15|unsloth\_Qwen3.5-27B-UD-Q4\_K\_XL|16.411|0.005087|1.000000|
|16|mradermacher\_Qwen3.5-27B.Q4\_K\_S|14.499|0.012364|1.043999|
|17|steampunque\_Qwen3.5-27B.Q4\_K\_H|14.864|0.012091|1.055620|

**Hardware:** i3-12100F — 64GB DDR4-3200 — RTX 3060 12GB
**Evaluation tool:** llama.cpp (mainline) version: 8189 (4d828bd1a)

Notes:
Those results have been taken after the latest wave of quant update but lmstudio have yet to fix them.
I haven't included DevQuasar since not only they haven't updated them but one of their quant is mxfp4 (which results in a Q8\_0 when it's not an MoE).
I haven't included dinerburger either since the quant is relatively massive (IQ4\_NL at 20.2gb, bigger than Q5\_K\_M).

--- TOP COMMENTS ---
This is excellent. In a sea of different options, this truly helps!

---

Thanks for the work! How come for models like bartowski\_Qwen3.5-27B-IQ4\_XS you show a 14.1GB size when huggingface shows 15.2? ..

Yesterday

Research

Developer Tools

/r/ClaudeAI

I've been building Claude Skills for a month. Here's what I learned the hard way.

When Skills launched I thought I understood them immediately.

I didn't.

I copied my best prompts, saved them as Skills, and expected magic. The output was fine. Maybe slightly better than before. Nothing that justified the hype I'd built up in my head.

So I went back to basics and asked myself: what's actually different about a Skill versus a prompt?

A prompt is a request. A Skill is a job description.

That one reframe changed everything.

**The project that put it in perspective**

A few months ago I helped a client double their organic search traffic. The two biggest levers were site architecture and schema markup — restructuring their page hierarchy for topical authority and implementing JSON-LD across the entire site.

It worked. But it took forever.

The architecture planning, the URL mapping, the schema for every page type — all done manually, all painfully slow. Good outcome. Terrible process.

That's what pushed me to build proper Skills around it. Not to replace the thinking, but to stop doing the same mechanical work by hand every single time.

The Site Architecture Planner now gives me a full page hierarchy, URL structure, and internal linking blueprint in minutes. The Schema Markup Generator produces valid JSON-LD for any page type in one pass. The same project today would take a fraction of the time.

The results still depend on the strategy. The Skills just stop the execution from being the bottleneck.

**What I got wrong at the start**

Looking back, my early Skills failed for three reasons:

Too vague on the role. "SEO expert" gives you SEO intern output. The more specific the identity, the better the reasoning.

Instructions instead of constraints. I was telling Claude what to do. The better move is telling it what it *cannot* do. No invented data. No vague recommendations. No generic advice that applies to every site. Constraints force precision in a way instructions never do.

No output format. If you don't define exactly how the output should look, Claude fills the gap with whatever feels natural. For professional work that's rarely good enough. A well-defined table forces structured thinking. A scoring rubric forces honest assessment.

**The thing about Skills nobody says out loud**

Your Skills are only as good as your thinking going into them.

I see a lot of people sharing Skills that are just long prompts with a name attached. They wonder why the output is inconsistent. The issue isn't Claude. The issue is the Skill doesn't tell Claude how to think — only what to produce.

The best Skills I built aren't the most complex ones. They're the ones where I was most precise about the role, the constraints, and the output. Three things. That's the whole formula.

**What are your experiences with Claude Skills so far? Have you found a setup that actually works for professional output?**

--- TOP COMMENTS ---
Load the skill-creator skill and let an agent do deep research on a topic (like SEO) and then hone in the skill until it's perfect.

Takes time but it's worth it (sometimes)

---

Why is everything written by AI these days. The tics and recycled prose is so clearly visible...

14h ago

Ai Top News

Hardware

Applications

Tools

Open Source

Research

Developer Tools

Models

Companies