Planetscale (assuming they used a agentic development practice) will have pulled this off, to the level of performance that they have, because they have a team of very highly experienced Postgres developers. Their knowlage of Postgres internals will have given them the insights needed to steer the models to a plan that used the architecture as described in the post. That's not something a model can do on its own*

World experts + LLMs = moving mountains.

(* we're obviously seeing something a little different from inside the research teams in the labs. They are showing that the models, when you burn the level of tokens only they can, are able to do novel things from the models own insights.)

2. Receipts: https://postimg.cc/8sDTTT0W

I think this was a first year project, and a small correction: mine want quite the same aspect ratio.

In a completely clean room environment where a designer had never seen a folding phone, but had all the context of the iPhone and everything Apple had done, they would develop almost exactly the same design and features.

Designers have also been exploring the concept of foldable devices for literal decades, well before any reached the market. I have an industrial design and technology degree, we did a project in 2005 where we explored the designs around this, looking at the UI, the physical interaction, everything. My design had a similar aspect ratio and size, as I am sure half the student did my year and every other year they ran the project. (the iPhone Duo is about thousand times better than my design though!)

Thats not to say the Microsoft designers didn't do an incredible job, they did, but they were building on decades of design ideation from those that had experimented before them.

WASM till recently has had a 32bit address space, to match the limitations of JS numbers. With 64bit WASM you have to use BigInt rather than the floats that are numbers in js to address the memory.

It's only the address space that's affected - old WASM still handled 64bit math fine.

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

Points: 4

# Comments: 1

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

Points: 3

# Comments: 0

It is very true that there are nuances you have to deal with when using CRDT toolkits like Yjs and Automerge - the merged state is "correct" as a structure, but may not match your scheme. You have to deal with that into your application (Prosemirror does this for you, if you want it, and can live with the invalid nodes being removed)

You can't have your cake and eat it with CRDTs, just as you can't with OT. Both come with compromises and complexities. Your job as a developer is to weigh them for the use case you are designing for.

One area in particular that I feel CRDTs may really shine is in agentic systems. The ability to fork+merge at will is incredibly important for async long running tasks. You can validate the state after an agent has worked, and then decide to merge to main or not. Long running forks are more complex to achieve with OT.

There is some good content in this post, but it's leaning a little too far towards drama creation for my tast.

An ai based development workflow with a concrete oracle works very well. You still need the research and planing to solve things in a scalable way, but it solves the "are the tests correct" issue.

What we've done is pull out failing property tests as a unit tests, makes regression testing during the agentic coding loop much more efficient.

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

Points: 2

# Comments: 0

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

Points: 290

# Comments: 197

In future everyone will expect to be able to customise an application, if the source is not available they will not chose your application as a base. It's that simple.

The future is highly customisable software, and that is best built on open source. How this looks from a business perspective I think we will have to find out, but it's going to be fun!

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

Points: 4

# Comments: 1

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

Points: 152

# Comments: 32

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

Points: 4

# Comments: 0

https://github.com/durable-streams/durable-streams

https://electric-sql.com/blog/2025/12/09/announcing-durable-...

When we built ElectricSQL we needed a resumable and durable stream of messages for sync and developed a highly robust and scalable protocol for it. We have now taken that experience and are extracting the underlying transport as an open protocol. This is something the industry needs, and it's essential that it's a standard that portable between provider, libraries and SDKs.

The idea is that a stream is a url addressable entity that can be read and tailed, using very simple http protocol (long polling and a SSE-like mode). But it's fully resumable from a known offset.

We've been using the previous iteration of this as the transport part of the electric sync protocol for the last 18 months. It's very well tested, both on servers, in the browser, but importantly in combination with CDNs. It's possible to scale this to essential unlimited connections (we've tested to 1 million) by request collapsing in the CDN, and as it's so cacheable it lifts a lot of load of your origin when a client reconnect from the start.

For the LLM use case you will be able to append messages/tokens directly to a stream via a http post (we're working on specifying a websocket write path) and the client just tails it. If the user refreshes the page it will just read back from the start and continue tailing the live session. Avoids appending tokens to a database in order to provide durability.