I’d say that works as a simple initial approach. Second step is clarifying the "return address" and protocol, but what’s nice is that the message can actually contain those, meaning the protocol itself can evolve seamlessly over time.

Which can also cause drift, though :/

That’s what really appeals to me. I’ve been fighting Claude Code’s attempts to put everything in memory lately (which is fine for personal preferences), when I prefer the repo to contain all the actual knowledge and learnings. Made me realise how these micro-improvements could ultimately, some day, lead to lock-in.

> Run in tmux and interrogate it how feature X works, then build me the equivalent as a pi extension.

I’ll give it a try!

Any insights / suggestions / best practices?

For that I usually get it reviewed by LLMs first, before reviewing it myself.

Same model, but clean session, different models from different providers. And multiple (at least 2) automated rounds of review -> triage by the implementing session -> addressing + reasons for deferring / ignoring deferred / ignored feedbacks -> review -> triage by the implementing session -> …

Works wonders.

Committing the initial spec / plan also helps the reviewers compare the actual implementation to what was planned. Didn’t expect it, but it’s worked nicely.

Scaleway and OVH? Although I’m not sure how they compare at scale to AWS / Azure / GCP.

But can’t be allowed to have a beer or a whisky, and isn’t able to freely consent to sleep with someone five or ten years older.

I wonder what the official legal justification for this dichotomy is, if there is any.

Edit: after looking it up, there doesn’t seem to be one.

I’m probably stating the obvious, but some things are complex and don’t have good universal solutions. Which is part of why we have judges and lawyers, not just laws.

My point precisely. Many people only start experiencing life as adults once they’ve been declared adults. Which kind of makes sense.

Maybe something more progressive than a random date would be better. Some countries already do it for some things (both in rights, responsibilities, and legal consequences), many also have specific framework for people who simply can’t be held responsible for themselves (with, often, abuses).

But it’s what we have.

I wouldn’t fully agree. All parties being adults doesn’t inherently remove the advantage very large age and experience gaps can give to one party over the other, especially when one is barely adult. 18 or 21 is just an arbitrary number, and one doesn’t suddenly become smart about these things just because the law says they are now legally full citizens, responsible for their acts and for themselves.

But I also agree it doesn’t make age gaps between adults inherently negative. It’s just… complicated.

Theoretically, such a service could allow you to "browse" even via SMS.

I mean, it’s a bit ridiculous to have to resort to that, but the situation itself is ridiculous.

They hit a wall with deployment, for now, but it’s amusing to watch.

And since I wouldn’t trust their stuff (or Claude’s) with a 10-mile long stick I strongly suggested we put it on Cloudflare behind eight layers of Access / Zero Trust. Easy deployment, and "solves" (if we can call it that) many of the security issues (or not; maybe I’m wrong).

Everything and anything people actually want or need, whether it’s every day or just for five minutes, that nobody else could be bothered to make.

Today most won’t know what to do with it, just like they didn’t know what to do with a web browser.

But that won’t last.

> and quickly realized throwing 5 mediocre models at a problem just makes them argue in circle.

What was your selection strategy? My current issue is more that the more models I add, the less likely any specific one is to win two rounds in a row. Which would make perfect sense no matter the model quality, no? Unless there’s a huge gap.

> For brainstorm mode maybe weight models by past accuracy instead of pure voting?

By adding outputs history and a way to track the actual outcomes?

In the past few weeks I (mostly Claude) cobbled together a Rust library + cli to run the same prompt across multiple models, through multiple rounds of iterative consensus.

Each model is fed the same initial prompt, produces an answer, then every model individually reviews and scores each of the other model's answers independently. The original prompt, previous answer, and the reviews, are then fed back to the models for the next round, until either one model "wins" two rounds in a row or a limit is reached.

It did quite well on the car wash test (https://github.com/Lightless-Labs/refinery?tab=readme-ov-fil...). Most models answer badly initially, but it just takes one for all of them to quickly converge towards better answers. Although, to my initial surprise, adding more models quickly breaks the current voting+threshold selection strategy.

I also recently added a synthesis mode, which does the same thing but with an additional synthesis round at the end where each model produces a synthesis of all the answers that scored above the threshold in the last round, followed by one last review round.

The total number of calls quickly blows up with rounds and model count, but it's been fun!

Currently, I'm racking my brain trying to figure out a way to select for both diversity and quality, for a "brainstorm" process. If you have any ideas either on that or other features, let me know!

Comments URL: https://news.ycombinator.com/item?id=47515351

Points: 2

# Comments: 2

Funny. I just stumbled upon that specific OpenDoc video today.

https://youtube.com/watch?v=oeqPrUmVz-o