It is a bit sensationalist to say this is reviving it though, which makes this sound like some wild issue.

Perhaps "creates CLAUDE.md for claude-code users by default" instead.

Ente is a private hosted photo storage and sharing platform. Only trusted devices that can decrypt /encrypt would even be able to perform the kind of work to tag photos for face recognition, and in this category I'm not aware of any hosted alyermative that actually does this, and they do a _pretty good job_ considering the limitations of E2EE.

Immich, Google Photos, Apple Photos- these platforms don't have to work around the fact all user data is opaque ciphertext. I imagine you could extend the capabilities of machine learning to a trusted node (similar to what you can do with Ente Desktop, but with more capable models), but they still have to work around any of that metadata being visible to them as well.

This takes somewhat trivial problems and makes them entirely non-trivial to solve. Self hosted platforms that don't provide an E2EE story have significantly less headache to deal with, especially since most people justify it by "it's running on my server so it's okay". And I get that, you can generally work around this issue with disk-level encryption and you're all good. It's just not the same product at all.

It's being run through the equivalent of a virtual machine. So it's really quite similar to the layers used to abstract away platform specifics like Wine / Proton does for Windows compatibility. Instead of DXVK you have WebGL.

Node and its ecosystem was considerably behind in multiple regards.

TypeScript is the most complex type system in existence. I am unsurprised it is difficult to port, but I am still a bit surprised by the length of the project thus far.

Like today, I told Claude exactly the name of the folder it had mistaken (it was supposed to be prod, not production), and it disregarded my input to then examine the directory itself. Small example of the kind of things it's been doing lately but that's top of mind.

The social connectivity and discoverability in github is a big reason many people use it. Can't say how many, but it is.

Migrate/optimize later when you're actually reaching scale is a perfectly reasonable approach.

In fact, if you have a decent abstraction or standard in place (e.g. S3 API or repository pattern) you can swap it out in place.

It's 90% AI, but that 90% was almost entirely boilerplate and would have taken me a good chunk of time to do for little gain other than the fact I did it.

Even then, a solid validation/parsing library like Zod is a better choice than casting, it is much less error prone at ensuring you have the right type applied.

Beyond that boundary, casting with `as unknown` is a massive code smell and often introduces any further use of that data to invalid type errors. I'll refer to this as "force casting", because simply casting "x as T" with sufficient strictness configured will still fail type checking if x is not compatible with T, and that can be fine for certain cases like reducing a complex type or giving an inferred parser type a form that fits your domain types.

Developers that force cast too readily can end up creating hundreds or even thousands of type errors in the codebase over time, and they are pretty quickly revealed once you peel away the casting. The same is true when starting from an `any`, where every reference thereon is equivalent to a force cast.

There can be some complex typing scenarios that do require it, but even then a good type guard works better even if certain cases can be semantically equivalent, you can write tests around guards as they're just functions, ensuring some logical correctness to the typing.

The simplest but maybe odd way to judge whether a casting is used the wrong way is to ask "are you lying to the type system?". If so, how can you better portray that type correctly (validation that determines a correct type for you (e g. Zod) or type guards).

name: A name: Al name: Ale name: Alex

Which would suggest you are getting unfinished strings out in the stream.