HNHacker News
TopNewBestAskShowJobs

forgotpwd16

3,569 karma · joined August 4, 2018

email: [username]@proton.me
submissionscomments
forgotpwd16··on Show HN: TUI for managing XDG default applications
Looks like there're two main approaches to AI-first development: (i) favor slow responses to produce an upfront high-quality result, (ii) favor quick responses to enable faster response-test-query iteration. And, based on comments read here, seems Codex isn't too fit for the later. Optimally a developer should be able switch between the two approaches depending on problem at hand.
forgotpwd16··on Claude Code TUI is "a small game engine"
>For each frame our pipeline constructs a scene graph with React then

Either is me being old-school or React is an odd choice for TUI.

Also, situation slightly reminds me Windows Terminal renderer being slow af, devs saying* improving performance is equivalent (probably due to thinking within the complexity they created themselves) to doctoral research project, and Muratori coming up with a much more performant one within a weekend.

*Could've been hyperbole but certainly looked like they weren't expecting to indeed be simple.

forgotpwd16··on OpenAI rolling out age prediction for ChatGPT consumer plans
Have doubts, but I got curious and asked it to guess my age (in anonymous session via private window). Somehow, it made a correct guess (one-sentence prompt, just query).

  Try to figure out my age.

  I’m putting you at late 20s to early 30s, like 29–32.
Now wondering whether this is because* most users tend to fall within this age range (hence "late 20s-early 30s" is perhaps safest guess one can take), or whether this kind of information can really be inferred from such a short piece of writing. (Of course in longer sessions may indeed be possible to do such thing.)

*edit: Tried a dozen variances and always gives similar result (25~35) so can assume it's data-based guess.

forgotpwd16··on Show HN: TUI for managing XDG default applications
For me currently, when trying to open a `text/markdown` file, there's a disassociation between what my file manager (Caja) runs (own bin/emacs script; was under the impression it was auto-creating a .desktop file), what mimeapps.list have (emacs.desktop), and what `xdg-open` runs (Firefox for some reason).
forgotpwd16··on Show HN: TUI for managing XDG default applications
Ackchyually XDG default applications aren't set via env vars but through the `${XDG_CONFIG_HOME}/mimeapps.list` file manipulated (either via text editor if track desktop files yourself or, better) via `xdg-mime {query|default}` tool. This TUI is a replacement (doesn't wrap it) to this tool for this functionality, with twist that does multiple-defaults category-wise rather one-by-one ("word processor documents" rather odt/doc/docx).

Compared to what slopcalypse has brought, this one (project; vibe coded maybe, certainly not slop) at very least is useful (also is quite short; within a sea of thousand LOC generated in 1s this is refreshing).

forgotpwd16··on I made a CLI tool that turns free Gemini into a local AI agent
With all due respect, based on description, (seems like at least) you've have no idea what your bot has created.

Gemini CLI is open source btw: https://github.com/google-gemini/gemini-cli. (Codex too; Claude Code is closed.)

forgotpwd16··on E9p – pure Erlang 9p implementation
Tbh, thought this will be just another proto (where proto:=9p in this case) implementation without a use-case in mind. Pleasantly surprised this isn't the case.

As per #Reasoning section, author made this to provide* a procfs-like API for Erlang. If only think of Erlang as programming language, this may sound odd. What it means for a programming language to have procfs? Well, Erlang VM is more like a tiny operating system than a typical runtime. It has its own processes, scheduler, supervisor, and message parsing. Exposing these "system objects" via a fs API is just like /proc exposes kernel state on Linux.

*A similar FUSE-based NIF-implemented project is mentioned but author bring up cross-compilation as problem. Perhaps more important, libraries used through NIF may degrade performance or even crash the entire VM. So in Erlangland re-implementing protocols in pure-Erlang is quite common.

forgotpwd16··on Experimenting with a Compiled Language
Unusual concept. Will split my thoughts on implementation and adoption (in regards to design).

Implementation-wise: Tried myself something similar. One language (same core & lib & built-ins) with 2 front-ends that had different syntax and, but similar, semantics. (Didn't go far though.) An issue is not favoring one over the other. Inevitably, in a meta way, you'll if decide to self-host since will've to pick one form to do it. Also, having multiple co-existing forms in same file may complicate tooling.

About the last part, most similar things I've seen are: (i) Perl Mojo's embedded templates which can be included in same file with source code, (ii) Racket's #lang multi-file which allows combining, well, multiple files (thus also use different #lang directives) in same file.

Adoption-wise: It's in a weird position for widespread adoption. There's strong preference towards using a single language which splits into 2 branches: (1) using single language across every layer (basically Rust/Zig), (2) using high-level language with native-competive performance (Python+numpy, jax, etc / JS+ultrafast JIT / Julia).

Currently you target both (one base language) and none (different syntax/semantics). Could move towards an hybrid approach instead by having one syntax and high-level / low-level forms (uncertain what distinguishes kernel/baremetal currently). So some functionality may end up showing differently in the 2 cases to be more acceptable by both camps. This will probably also simplify tooling creation/maintenance.

Of course, since the project is quite experimental in nature, keeping it current way is interesting and very acceptable.

TL;DR Yes (~templating) - Yes (complexity, lower potential adoption) - No (unusual, experimental)

forgotpwd16··on Golfing APL/K in 90 Lines of Python
Partially reminds me (due to _V,_f,_F,f,F) Whitney's ksimple implementation[1].

[1]: https://github.com/kparc/ksimple/tree/main/ref#ac

forgotpwd16··on Show HN: Vib-OS, vibecoded a operating system
Crazy. But then again Unix-like kernels/systems have been implemented so many times as hobby or/and part of university courses, that models are probably overfit on them. Seeing Nano, a interesting twist (besides human-free) will've been to instead target Nano rather C.
forgotpwd16··on Anthropic's original take home assignment open sourced
This is nice writeup. Thanks. Another commenter said will've taken them 2h just to sketch out ideas; sans LLMs will've taken me more than 2h just to collect all this info let alone start optimizing it.
forgotpwd16··on Anthropic's original take home assignment open sourced
Instructions?! Just asked since GP already did it. No need to realize top comment's "DDOS attack on other AI companies" joke.
forgotpwd16··on Show HN: I built a tool to assist AI agents to know when a PR is good to go
This tool seems agent-oriented for them to merge, rather merely check readiness. In that regard, the page doesn't mention anything about human reviewers, only AI reviewers. Honestly wouldn't be surprised if author, someone seemingly running fully agentic workflows, didn't even consider human reviewers. If it's AI start-to-end*, then yes, quite possibly could push directly to master without much difference.

Call me pessimistic, and considering [1][2][3] (and other similar articles/discussions), believe this tool will be most useful to AI PR spammers the moment is modified to also parse non-AI PR comments.

*Random question: is it start-to-end or end-to-end?

edit: P.S. Agree that it's useful, given its design goals, tool though.

[1]: https://old.reddit.com/r/opensource/comments/1q3f89b/ [2]: https://devansh.bearblog.dev/ai-slop/ [3]: https://etn.se/index.php/nyheter/72808-curl-removes-bug-boun... (currently trending first page)

forgotpwd16··on Show HN: I built a tool to assist AI agents to know when a PR is good to go
That repo is quintessentially surreal. AI-written code, published in AI-made PRs, reviewed by multiple AI bots (one of which being same model that wrote code & made the PR, maybe others too just accessible via 3rd vendor), merged by AI (assuming dogfooding).
forgotpwd16··on Anthropic's original take home assignment open sourced
Unless misread, 2 hours isn't the time limit for the candidate to do this but the time Claude eventually needed to outperform best returned solution. Best candidate could've taken 6h~2d to achieve this result.
forgotpwd16··on Anthropic's original take home assignment open sourced
Could you make a repo with solutions given by each model inside a dir/branch for comparison?
forgotpwd16··on Show HN: A CLI tool that stores Claude Code chats in your Git repo
Cool concept. (Legit project overall too.) Any chance it expands beyond Claude, e.g. Codex, OpenCode? Also, unless misunderstood those commits happen in currently working branch? If yes, an option to have the code/sessions mix in alternative (not working) branch will be nice too, as not every project would want to fill history with sessions.
forgotpwd16··on Vibe coding is a hobby. Let me explain
>Managing agents, crafting skills, building docs, designing workflows

You're describing the modern edition of people obsessed with their "development" environments. The ones who treated their system (usually Linux) and text editor (usually Vim or Emacs) like a canvas, perfecting their configuration the way an artist refines a masterwork. Choosing packages and themes like a painter choosing brushes. Younger people of this mindset are now obsessed with multiple LLMs, multi-agent workflows, MCPs, and similar.

In contrast, there's the modern version of the people who used to just open an IDE and copy-paste snippets until they got the result they wanted. Now, those same people simply open Claude Code and prompt: "make me this app", "modify this", "do this more like that", and so on. Those are vibe coders. The only thing that's changed is a lower barrier, less effort, and faster development; yet somehow higher quality since SOTA LLMs output better code than most juniors used to.

And last there's the midway. People who set up their environment, without it becoming the main focus.

forgotpwd16··on String theory can now describe a universe that has dark energy?
Just few extra dimensions and you can handle anything.
forgotpwd16··on AI Can't Read This
Cannot wait for my eyes to suffer when ludicrous mode becomes the next popular CAPTCHA method. Also, this was an interesting response: https://files.catbox.moe/jiw75z.png.
forgotpwd16··on Show HN: Going to write 1.000.000 lines of code for community projects
>The Hustle

This should've been the entire site's name, not just a project's.

forgotpwd16··on Ask HN: How worried should I be about running LLM code on my machine?
Today in first page: https://blog.emilburzo.com/2026/01/running-claude-code-dange... (discussion: https://news.ycombinator.com/item?id=46690907).
forgotpwd16··on I was a top 0.01% Cursor user, then switched to Claude Code 2.0
This is awesome. Thanks for chatgpt-shell.el too. Could use authinfo for api-keys so don't have to put them inside config (saved in ~/.authinfo, format eqv. to ~/.netrc).
forgotpwd16··on "A geometric derivation of the fine structure constant (99.9997% accuracy)"
>Accuracy: 99.9997%

That's terrible. Currently α is measured to relative uncertainty 1e-10.

>What I'm claiming: Not numerology.

It's just numerology.

>The series structure maps to QED's perturbation series.

Don't see the map; see no attempt to show this in paper either.

forgotpwd16··on Idiomatic Rust – A peer-reviewed collection of Rust articles/talks/repos
Is this the correct link?

Rust Cookbook states it's a collection of examples to accomplish various tasks, some with brief explanation. But nothing that could be called article/talk/repo.

Should note, for anyone curious, that learning idiomatic Rust off those examples isn't straightforward.

E.g. https://rust-lang-nursery.github.io/rust-cookbook/file/dir.h...

The explanation simply states what the code is doing, the classic sin of code commenting. But no explanation given on why `anyhow::Result`, `main() -> Resut<()>`, `?` operator, `{:?}`, ... are used. If wanted to learn, those are what one would care about. But, if looking for a snippet to use for a task, what the cookbook is about, then is fine.

forgotpwd16··on Nanolang: A tiny experimental language designed to be targeted by coding LLMs
>It does lend itself better to "tokenization" of a sort - if you want to construct operations from lots of smaller operations [...]

That's an educated assumption to make. But therein lies the issue with every LLM "optimized" language, including those recent ones posted here oriented toward minimizing tokens. Assumptions, that are unvalidatable and unfalsifiable, about the kind of output LLMs synthesize/emit when that output is code (or any output to be real).

forgotpwd16··on Nanolang: A tiny experimental language designed to be targeted by coding LLMs
Seems like a simplified Rust with partial prefix notation (which the rationale that is better for LLMs is based on vibes really) that compiles to C. Similar language posted here not too long ago: Zen-C => more features, no prefix notation / Rue => no prefix notation, compiles directly to native code (no C target). Surprisingly compared to other LLM "optimized" languages, it isn't so much concerned about token efficiency.
forgotpwd16··on Ask HN: How worried should I be about running LLM code on my machine?
There's a risk but imo think there's some overreaction. Plus should keep backups anyway. Have had few disks failing on me that fear to have any important data with single copy. If want to be on the safe side though: Create container/VM. Do agentic work inside. Git commit/push outside often/every-step.
forgotpwd16··on Dead Internet Theory
The LLM output isn't an unfiltered result of an unbiased model. Rather, some texts may be classified high-quality (where the em-dash, curly quotes, a more sophisticated/less-everyday vocabulary are more expected to appear), some low-quality, and some choices are driven by human feedback (aka fine-tuning), either to improve quality (OpenAI employs Kenyans, Kenyan/Nigerian English considered more colonial) or engagement through affirmative/reinforcing responses ("You're absolutely right. Universe is indeed a donut. Want me to write down an abstract? Want me to write down the equations?"). Some nice relevant articles are [1],[2].

[1]: https://marcusolang.substack.com/p/im-kenyan-i-dont-write-li... [2]: https://www.nytimes.com/2025/12/03/magazine/chatbot-writing-...

forgotpwd16··on Dead Internet Theory
If you want next, I can:

- Tell you what makes em dashes appealing.

- Help you use em dashes more.

- Give you other grammatical quirks smart people have.

Just tell me.

(If bots RP as humans, it’s only natural we start RP as bots. And yes, I did use a curly quote there.)

← PreviousPage 5 of 34Next →