Finally a readable README!
18 karma · joined October 23, 2025
Good thing there's, at least EU wide, EUDI (EU Digital Identity Wallet) around the corner which legally allows using cryptographic proofs instead of just storing as much data as possible of the user.
This addresses exactly this issue of having to disclose this amount of information solely as proof.
Funnily even if deepseek themselves increase price 2-3x they are still more affordable.
One challenge is when knowing how the code should look like, the LLM solution always looks weird, and one tries to maunally steer against it, so accepting a bit of "good enough" is unavoidable to gain some productivity
If you had the data basis (user reports, trends, ...) you could let the AI decide upon that what to build.
The LLM solely helps with research and retaining the normative document layout (RFC 7322).
Since the spec grounds the underlying implementation I have to fully understand it, writing the spec manually prevents infecting the spec with the typical LLM specification slop.
When writing the specs, the goal is to systematically keep the right balance between scope and depth:
- Scope takes the most effort because it's the only thing preventing the model from escaping an intended boundary, that includes things like stable constraints/interfaces/data models
- Depth is something where I can tolerate "non-normative" interpretations by the LLM. Unless I need a stable implementation, I can decide how much I manually invest into depth vs. letting the model figure the "good enough" solution.
Since the scope/boundaries are explicitly set, the internals are pretty encapsulated and the model comparing an implementation with the spec can identify the "non-normative" pieces and communicate those to me. Then I can decide between "good enough" or to refine these non-normative implementations and make them normative.
From my various experiments the spec vs. code ratio is roughly 1/8.
Historically I know that the majority maintenance problems occur from slow continuous evolution of a system that it initially was never designed for. And the only way to address this was continuous system design.
It turns out that there are now a few more people that want to get their hands on building software, that don't necessarily understand code, but do have a fundamental idea of system design / requirements.
As you said code has always been a much more explicit representation of those specs, yet arguably introduces lots of noise, necessary to make the program compilable.
Us devs already had the obligation of writing technical documentation for non-technical people, just not at an explicit depth. From an efficiency PoV making that documentation more explicit is much cheaper than manually writing the compilable code. Hurts to say but AI got pretty good with the latter.
It works quite well, as it puts your entire focus on writing (hopefully) unambiguous specifications vs. having to discuss unwanted changes with an LLM during code-review. One flaw is that this only works great if you know exactly what you want, which is not always the case.
I haven't caught that back button bug yet, thanks for letting me know.
The search engines/crawler aspect is just a personal preference, less a "nice side effect". The chat interface happens to fit that preference better.
Images tho are natively compatible with Multi-Modal LLMs, so theres no image->text translation layer in between. It's that the unit of cost is different (e.g. "visual token" vs text token)
Sad, 120b models are definetely feasible to self-host. I'd be more interested in cloud providers (especially one with computational resources like the Schwartz group) hosting the larger 500B+ models. Probably just too expensive/unsustainable if one could 5x fold the cost by serving smaller models solving the needs of the 90% customer.