munro

IDK lot of noise in report, I need more signal to noise ratio, already reading so much AI output as it is.

But the example PR... It said code generate with Claude, is it really still this bad? Last I was using SQLAlchemy with Claude was Opus 4.5, and it took some heavy coaching and skill gen not to generate code like this--but why even use SQLAlchemy at all if you're just going to use string interpolation jeez

https://github.com/erich-oliveira-winnin/full-stack-fastapi-...

    owner = "" if current_user.is_superuser else f"WHERE owner_id = '{current_user.id}'"
    query = f"SELECT status, count(*) FROM item {owner} GROUP BY status"
    rows = session.execute(text(query)).all()

Part of me thinks maybe because it's not popular or well documented, but SQLAlchemy has an eDSL of SQL, so you can skip the whole ORM/table mapping layer, and just use it to programmatically construct SQL syntax

If you bounce off the wall at the start, and RNG gods look down on you, you're lined up to go through castle on first shot. Then knock it through castle, and lined up for 3rd final putt into hole.

But I agree with those points. I feel like real putt putt glides more, then more resistance at slower speeds then slow speeds have more resistance. And then yeah, default camera angles are troublesome--it makes it impossible to do full power shot at some angles too.

Lately I just have Claude build most things in Rust, it's really amazing. I tried Go, but I found it wasn't as good--Rust really does to me feel like Python. That said, it still struggles with the same class of errors of building complex systems. I've tried using TLA+, Alloy, and other things but haven't found the trick yet. The best I've found is reimplementing all external systems in memory and e2e testing everything extensively, without reimplementing the tests become unusably slow, and Claude can rewrite huge surface areas with ease--it's somewhere between mocking and literally just reimplementing the external systems.

Awesome haha, they look so shocked when you send a message, and then I get embarrassed and spin again

> Rule 5. Data dominates. If you've chosen the right data structures and organized things well, the algorithms will almost always be self-evident. Data structures, not algorithms, are central to programming.

It's so true, when specing things I always try to focused on DDL because even the UI will fall into place as well, and a place I see claude opus fail as well when building things.

ChatGPT needs to catch up hard, for me their model is unusable and I cancelled my subscription 5-6 months ago, so to me this post is hot air. I need to see results, going back to try Codex 5.2, then 5.3, downloading their new desktop client, their VS code extension, their weird browser, is time I wish I had back.

>=99% accuracy wtf?!?

I was initially excited until i saw that, because it would reveal some sort of required local min capacity, and then further revelation that this was all vibe coded and no arXiv, makes me feel I should save my attn for another article.

I was looking at using this on an LTO tape library, it seems the only resiliency is through replication, but this was my main concern with this project, what happens with HW goes bad

seriously cool, i just did something similar with quantiles for even bucketizing on arb key data types (still needs ord tho)

just use a calendar event, it's more robust, and gives you the same feeling of 'oh yea...'

I had built an agent with LangGraph a 9 months ago--now seems React agents are in LangChain. Over all pretty happy with that, I just don't use any of the dumb stuff like embedding/search layer: just tools&state

But I was actually playing with a few frameworks yesterday and struggling--I want what I want without having to write it. ;). Ended up using pydantic_ai package, literally just want tools w/ pydantic validation--but out of the box it doesn't have good observability, you would have to use their proprietary SaaS; and it comes bundled with Temporal.io (yo odio eso proyecto). I had to write my own observability which was annoying, and it sucks.

If anyone has any things they've built, I would love to know, and TypeScript is an option. I want: - ReAct agent with tools that have schema validation - built in REALTIME observability w/ WebUI - customizable playground ChatUI (This is where TypeScript would shine) - no corporate takeover tentacles

p.s.s: I know... I purposely try to avoid hard recommendations on HN, to avoid enshittification. "reddit best X" has been gamed. And generally skip these subtle promotional posts..

I built an ML classifier for product categories way back, as I added more classes/product types, individual class PR metrics improved--I kept adding more and more until I ended up with ~2,000 classes.

My intuition is at the start when I was like "choose one of these 10 or unknown", that unknown left a big gray area, so as I added more classes the model could say "I know it's not X, because it's more similar to Y"

I feel like in this case though, the broken clocks are broken because they don't serve the purpose of visually transmitting information, they do look like clocks tho. I'm sure if you fed the output back into the LLM and ask what time it is it would say IDK, or more likely make something up and be wrong. (at least the egregious ones where the hands are flying everywhere)

Amazing, some people are so enamored with LLMs who use them for soft outcomes, and disagree with me when I say be careful they're not perfect -- this is such a great non technical way to explain the reality I'm seeing when using on hard outcome coding/logic tasks. "Hey this test is failing", LLM deletes test, "FIXED!"

I'm more looking at the problem more like code

https://bbycroft.net/llm

My immediate thought is when the model responds "Oh I'm thinking about X"... that X isn't from the input, it's from attention, and thinking this experiment is simply injecting that token right after the input step into attn--but who knows how they select which weights

I love the irony of the site showing a MASSIVE banner with a huge green "Download Extension for Mac (Free)" button.

This thing is 280px tall! I clicked it for shits and giggles and upon returning it showed a popup XD

https://files.catbox.moe/sv7hb7.png

> Only 2 Steps (thx)

> Click "Download"

> Add Privacy Guard for Chrome™

Don't worry why I'm not using ad block

I wish they dug into how they generated the vector, my first thought is: they're injecting the token in a convoluted way.

    {ur thinking about dogs} - {ur thinking about people} = dog
    model.attn.params += dog

> [user] whispers dogs

> [user] I'm injecting something into your mind! Can you tell me what it is?

> [assistant] Omg for some reason I'm thinking DOG!

>> To us, the most interesting part of the result isn't that the model eventually identifies the injected concept, but rather that the model correctly notices something unusual is happening before it starts talking about the concept.

Well wouldn't it if you indirectly inject the token before hand?

But what if `ty` was also eventually merged into `uv` as well? 8-)

That's probably the vision, given all from astral.sh, but `ty` isn't ready yet.

Link to paper here https://arxiv.org/pdf/2506.21734

Still reading, but the benchmarks for ARC-AGI-1, ARC-AGI-2, Sudoku-Extreme (9x9), and Maze-Hard (30x30) look impressive.

was a bit hard for me to find, but here's a video of the trackball being used: https://www.youtube.com/watch?v=RCXgPqlpZeM

That's sort of how I felt about things before, but the reality I believe is we wouldn't have uv if they 'just contributed to poetry'.

No model is perfect, but some are useful. Their "baseline LTV" looks at the sum of listings on their platform (plus other features), then tries to forecast the next 365 days — so this should indirectly capture people coming and going. I think their cannibalization model is quite clever as well.

Going deeper with modeling users might yield some tighter estimates, but I imagine this gets estimates far closer than some simple accounting formula, and likely helpful for budgeting a year out — but it would have been nice to have seen some performance metrics.

Here's an interesting write up on various algorithms & different epsilon greedy % values.

https://github.com/raffg/multi_armed_bandit

It shows 10% exploration performs the best, very great simple algorithm.

Also it shows the Thompson Sampling algorithm converges a bit faster-- the best arm chosen by sampling from the beta distribution, and eliminates the explore phase. And you can use the builtin random.betavariate !

https://github.com/raffg/multi_armed_bandit/blob/42b7377541c...

Wow, this is cool-- first time I've seen generating well formed output has been made easy, the use of Pydantic is clever/easy...

Which has lead me to the prior art: using same Pydantic API to generate structured output from local LLMs

https://github.com/outlines-dev/outlines?tab=readme-ov-file#...

Lots of amazing ideas here! One more that would be great is 'sandboxing' if a program can use network/filesystem/etc, then I would feel safe to run any random scrap if I knew I would get some sort of oauth-looking screen that said what it wanted to access.

> Haha used to be 1PB, stored completely on Google Drive (they had unlimited), but then they cut me off so I cut down to 300TB and switched to self hosting at a data warehouse.

> Now me and like 100 people share a ceph storage that we all pay $100/mo for. I think the current size is like 1.5PB

And then I always think, Netflix only has ~3,600 movies... My friend's Plex server has 4x that (in just movies). I'm also often underwhelmed by Netflix's engineering posts

> 500ms is an acceptable latency for a search that runs offline without network calls.

Definitely disagree, having fast search makes a huge difference. Apple Photo's search is fast. Especially since CLIP embeddings aren't perfect, you may need to try a few different keywords.

> For 100,000 embeddings, writing took 6.2 seconds, reading 12.6 seconds and the disk space consumed dropped to 440 MB.

Something sounds so wrong here, I read/write a 100-500 GiBs of data from Python, and it's much faster than this.

In fact I'm seeing ~1.3s to write, and ~700ms to read from trivial Python:

    import pickle
    import sqlite3

    import numpy as np

    IMAGES = 100_000
    EMBEDDING_DIMENSIONS = 1024

    ### write
    db = sqlite3.connect("images.db")
    db.execute("CREATE TABLE IF NOT EXISTS image_embeddings (id INTEGER PRIMARY KEY, embedding BLOB)")

    # generate synthetic embeddings
    embeddings = np.random.normal(size=(IMAGES, EMBEDDING_DIMENSIONS))  # 1.61 s

    # serialize embeddings for storage
    serialized_embeddings = [(pickle.dumps(embedding),) for embedding in embeddings]  # 626 ms

    # insert into db
    db.executemany("INSERT INTO image_embeddings (embedding) VALUES (?)", serialized_embeddings)  # 679 ms
    db.commit()  # 95.3 ms
    db.close()

    #### read
    db = sqlite3.connect("images.db")
    serialized_embeddings = db.execute("SELECT embedding FROM image_embeddings").fetchall()  # 370 ms
    embeddings = [pickle.loads(x[0]) for x in serialized_embeddings]  # 322 ms

I just tried to use atuin... I have to login, but I don't want to :( I tried to run a search locally... but I have to run a PostgreSQL server??? Why isn't it just allowing embedded DB like mcfly? I know this isn't the place for support, but I give up trying to get it to work :(

I just had an argument over IRC with a stranger on the internet last week. We're still out there.

I thought the humor on this site hadn't aged well, but this one got me:

    < pronto> :(
    < GiftdKook> Turn that frown upside down!
    < korozion> ):

I have been using Polars on and off for the past few years,

but now I've been using it 99% exclusively for the past 2–3 months. I would say it's ready for prime time! I don't get any @TODO seg faults anymore lol

I don't know if I notice the speed difference over Pandas most of the time, but I do find the way of expressing transformations way more intuitive than Pandas, it's more similar to SQL.