emschwartz

I agree that Opus feels like a step change.

Claude code with sonnet was pretty good but needed a lot of back and forth to get to the right solution. Opus feels closer to a colleague, maybe not your absolute best colleague, but far from your worst.

It's very fun to try to make that limited data model do more than it was intended to.

When I did a little bit of contracting for TigerBeetle, I was working on these learning exercises and came up with some fun ingredients that could be used if you're trying to push what's possible https://github.com/tigerbeetle/tigerlings/pull/2

Glad you think so!

There isn't a way to block feeds (yet), but you can subscribe to specific feeds, which basically acts like creating your own list of allowed feeds.

Separately, I'm going to be working on letting you exclude content from certain domains (which was requested in https://feedback.scour.ing/33).

Indexing into arrays and vectors is really wise to avoid.

The same day Cloudflare had its unwrap fiasco, I found a bug in my code because of a slice that in certain cases went past the end of a vector. Switched it to use iterators and will definitely be more careful with slices and array indexes in the future.

Give Scour a try!

It ranks articles by how closely related they are to your interests. You can import a set of RSS feeds or scour all 15,000+ sources.

I built it because I wanted to find the good articles among noisy feeds like HN Newest. I've also avoided RSS readers in the past because of that feeling of having thousands of unread emails.

https://scour.ing

How does the approach here differ from dom_smoothie (https://github.com/niklak/dom_smoothie)?

I built Scour to help me sift through noisy sources like HN Newest. For each article in my Scour feed, I can click the Show Feeds button to find what other sources that post shows up in. I’ve found that to be quite a nice way of discovering people’s blogs that I wouldn’t have found otherwise.

You can also scour all 14,000+ sources for posts that match your interests.

https://scour.ing

If you’re looking to put one up, try https://bearblog.dev (no connection, just appreciate Herman’s work).

It’s got just the features you need, is built by a solo dev, and it’s got a very fair split between free and paid features. I used it to put up my personal site and have been very happy with the experience.

Agreed. For a Rust project, running Clippy and rustfmt is slow, but I’d be surprised to learn that pre-commit itself was a non-negligible part of that.

Very interesting! I especially appreciated the test of running models against the same benchmark from the following year and the point about the per-token discount being negated by models needing more tokens to get to the answer.

Generalization:

> Maybe Chinese models generalise to unseen tasks less well. (For instance, when tested on fresh data, 01’s Yi model fell 8pp (25%) on GSM - the biggest drop amongst all models.)

> We can get a dirty estimate of this by the “shrinkage gap”: look at how a model performs on next year’s iteration of some task, compared to this year’s. If it finished training in 2024, then it can’t have trained on the version released in 2025, so we get to see what they’re like on at least somewhat novel tasks. We’ll use two versions of the same benchmark to keep the difficulty roughly on par. Let’s try AIME:

> Almost all models get worse on this new benchmark, despite 2025 being the same difficulty as 2024 (for humans). But as I expected, Western models drop less: they lost 10% of their performance on the new data, while Chinese models dropped 21%. p = 0.09.

> Averaging across crappy models for the sake of a cultural generalisation doesn’t make sense. Luckily, rerunning the analysis with just the top models gives roughly the same result (9% gap instead of 11%).

Cost-effectiveness:

> Distinguish intelligence (max performance), intelligence per token (efficiency), and intelligence per dollar (cost-effectiveness).

> The 5x discounts I quoted are per-token, not per-success. If you had to use 6x more tokens to get the same quality, then there would be no real discount. And indeed DeepSeek and Qwen (see also anecdote here about Kimi, uncontested) are very hungry.

Extremely helpful. I've been eagerly awaiting v0.5 but have been holding off on deploying it until I had more confidence that it would work and be stable. Reading this, I'm definitely glad that I waited.

Does anyone have a detailed comparison of the functionality you get from Datastar versus HTMX + Alpine.js? My impression was that Datastar was trying to be a lighter weight combination of the other two.

Scour lets you add feeds and topics that you’re interested in and then sorts posts by how similar they are to your interests.

It also works well for feeds that are too noisy to read through manually, like HN Newest.

https://scour.ing (I’m the developer)

Very excited for this release!

This is the blog post and HN discussion where they announced the intention to go this direction:

https://fly.io/blog/litestream-revamped/

https://news.ycombinator.com/item?id=44045292

Duolingo is great at gamification and terrible for actually teaching you the language. You memorize a ton of random words without really learning how to put everything together.

I found Babbel to feel much more like an app designed by language instructors.

Thank you for saying that too!

Hope this explanation helped explain why, at least a little bit.

The SQLite CLI has a `.expert` command that will give index recommendations when you run queries: https://sqlite.org/cli.html#index_recommendations_sqlite_exp...

It's not quite the same as capturing all of the queries used in development (or production), but it seems somewhat useful.

I'll also note that I had an LLM generate quite a useful script to identify unused indexes (it scanned the code base for SQL queries, ran `EXPLAIN QUERY PLAN` on each one to identify which indexes were being used, and cross-referenced that against the indexes in the database to find unused ones). It would probably be possible to do something similar (but definitely imperfect) where you find all of the queries, get the query plans, and use an LLM to make suggestions about what indexes would speed up those queries.

Thanks for saying that! That’s exactly how it was intended and I’m glad to hear you enjoyed it

That is a helpful way of thinking about it. Thanks for sharing!

Just to clarify one thing: the order of WHERE conditions in a query does not matter. The order of columns in an index does.

That’s excellent to hear!

Let me know if you have any other feedback as you use it more!

For sure. I’m curious if anyone using it in production as an alternative to SQLite and, if so, what the performance and experience is like.

Thanks for the heads up! I'll get that fixed

TBH, _I_ was also genuinely surprised when I made the initial MVP of Scour, pointed it at HN Newest, and right away was finding great posts with only 1-3 points.

I thought a lot of good stuff was probably getting buried in the fire hose, but I had no idea how well it would actually work at finding those hidden gems for me.

I think this is a neat direction to explore. I've wondered in the past whether you could use https://pglite.dev/ as if it were SQLite.

Hearing this makes my day :)

Feedback is extremely welcome! Feel free to email ideas to me (in any state of polish) or post them on https://feedback.scour.ing. Looking forward to hearing your suggestions!

Developer of Scour here. Really glad to hear you're enjoying it!

Comments like these are very motivating, so thank you!

Sounds interesting, though that durability tradeoff is not one that I’d think most people/applications want to make. When you save something to the DB, you generally want that to mean it’s been durably stored.

Are there specific applications you’re targeting where latency matters more than durability?

This is so detailed and easy to understand. Thank you for writing this up.

This looks useful! I appreciate that it stores everything as blobs and doesn’t require building the indexes first.

Any plans to support binary quantized vectors and hamming distances?