HNHacker News
TopNewBestAskShowJobs

baalimago

1,295 karma · joined July 16, 2017

learning...

https://github.com/baalimago https://lorentz.app

submissionscomments
baalimago··on Le Chat: Custom MCP Connectors, Memories
Strongest argument I see for Mistral is that it's European. Which isn't a very good argument.
baalimago··on Anthropic raises $13B Series F
Prediction: this is the final big "hufff" before the bubble bursts.
baalimago··on Cognitive load is what matters
Hey, OP, stop bashing on functional languages..!
baalimago··on Cognitive load is what matters
The same principle applies within context engineering
baalimago··on Altered states of consciousness induced by breathwork accompanied by music
"HN commenteers encounter joke - It flew completely by them"
baalimago··on VIM Master
I like the idea of vimgolf, but almost every "good solution" is a regexp replacement. Which is a problem since outside of vimgolf, I've very rarely used i. The usecase of vim regexp is quite narrow, basically only used in converting files between formats (a task I'd rather use other tools for)
baalimago··on Altered states of consciousness induced by breathwork accompanied by music
"Scientists in 2025 discover meditation - Their minds were blown"
baalimago··on Google will allow only apps from verified developers to be installed on Android
What about webapps?
baalimago··on AGENTS.md – Open format for guiding coding agents
The ironic thing about this is that it's equally valuable for anyone contributing the project. But for some reason it's only prioritized to make LLMs follow styleguide, humans need not apply (?)
baalimago··on Left to Right Programming
You don't need to be bothered with minute details such as syntax for counting string length anymore, you just need to know what you want to do. I mention this since OP is bringing up LSP's as an argument for why certain language's design is suboptimal.

"Count length of string s" -> LLM -> correct syntax for string-count for any programming language. This is the perfect context-length for an LLM. But note that you don't "complete the line", you tell the LLM what you want to have done in full (very isolated) context, instead of having it guessing.

baalimago··on [dead]
> User: vibe coded script?

> HN: No thanks!

> User: vibe coded script... with AI?

> HN: Oh boy, now we're talking..! Upvote, upvote..!

baalimago··on Show HN: Phind.design – Image editor & design tool powered by 4o / custom models
I have a standardized test I use for testing AI image editors, which I ran on Phind.design as well: I have a close-up picture a keyring which has a small hand-drawn painting of my puppy Freija. So my hand is visible in the image, as I'm holding the keyring. I ask the LLM to extract the puppy from the keyring, enlarge it so it fills the entire image and saturate the colours so that the hand-drawn painitng is the only thing which remains. I'm not interested in the picture of my hand holding a keyring, but the hand-drawn painting of the puppy.

This is somewhat trivial to do in Photoshop/Gimp. Hell, I'm sure most of you can visualize this transformation in your minds even. But it seems to be almost impossible for any AI image editor, Phind.design included.

What I got when I tried this using Phind was the very opposite of what I asked: it kept my hand holding the keyring, the keyring itself, but it replaced the puppy. Perhaps this is user error: should I not select the area I'd like to edit? Regardless, there were no attempts to coach me into using the tool correctly, even though the instructions might have been counter-intuitive, which I'd expect is half the point in using an AI tool.

So, well.. Maybe designers are safe for another day.

baalimago··on TODOs aren't for doing
// TODO(<issue-tracker-id>): <Short description>

This format allow for quickly finding the place where the thing needs to be done, while keeping track of the issue in the issue tracker.

I often write the issue tracker ID's in my code to add additional context. It works especially well for bugs which are reproducable in programatic tests. Then I name the test specification after the ticket, so that it's known that this bug doesn't resurface as regression.

baalimago··on Kiro: A new agentic IDE
1000 interactions ($20/month) will run out in a 1-2 hours. Do the math for 3000 interactions.

Kiro has the same problem as many LLM coding tools has: it's not economically sustainable for the company producing the tool (bubble will burst at some point), or it's not worth it for the developer.

baalimago··on Tell HN: I Lost Joy of Programming
There's programming for fun, and it's programming for work.

Why would you program in a non-joyus way if you're doing it for fun? For professional work I fully get why you'd want to optimize.

baalimago··on Mercury: Ultra-fast language models based on diffusion
I, for one, am willing to trade accuracy for speed. I'd rather have 10 iterations of poor replies which forces me to ask the right question than 1 reply which takes 10 times as long and _maybe_ is good, since it tries to reason about my poor question.
baalimago··on LLMs as Compilers
>if the issue with deterministic generation would be solved

This can be achieved by utilizing tests. So the SWE agent will write up a set of tests as it understands the task. These are the functional requirements, which should/could be easily inspected by the BI (biological intelligence).

Once the functional requirements have been set, the SWE agent can iterate over and over again until the tests pass. At this point it doesn't really matter what the solution code looks like or how it's written, only that the functional requirements as defined via the tests are upheld. New requirements? Additional tests.

baalimago··on LLMs as Compilers
I've had the same exact thought! The reason why we've moved from higher to higher level of programming language is to make it easier for humans to describe to the machine what we want it to do. That's why languages are semantically easier and easier to read js > cpp > c > assembly > machine code (subjectively, yes yes, you get the point). It makes perfect sense to believe that natural language interpreted by an LLM is the next step in this evolution.

My prediction: in 10 years we'll see LLMs generate machine code directly, just like a normal compiler. The programming language will be the context provided by the context engineer.

baalimago··on Ticket-Driven Development: The Fastest Way to Go Nowhere
If you don't like it, maybe swap jobs. As a tip: There's very little time for ticket driven development in startups.
baalimago··on Gemini CLI: your open-source AI agent
I'm glad you asked (to be honest that was half the reason I posted the comment)

I use Clai[1] which I've written myself, so it fits my workflow the best. But I know llm [2] is a popular choice as well.

With both of these it's possible to have a 'vendor agnostic' version of both claude code and gemini CLI. Better yet: it's possible to very easily swap to the latest and greatest vendor by simply specifying their latest fancy new model.

[1]: https://github.com/baalimago/clai [2]: https://github.com/simonw/llm

baalimago··on Gemini CLI: your open-source AI agent
Sounds like a context feeder to me. There's already tons of these, with mcp support, which are multi-vendor. Why lock yourself to a single vendor?
baalimago··on Nano-Vllm: Lightweight vLLM implementation built from scratch
So... It's a language model..? As in, not "large"? I'm a bit unsure of the magnitudes here, but surely "nano" and "large" cancel out
baalimago··on AGI is Mathematically Impossible 2: When Entropy Returns
I asked some LLMs all the questions stated in section 3, and they found an answer without diverging. So the entire premise seems speculative: just try out the LLMs to find how they act instead of 'straw-man'-ing what their response is.

In addition, how does the example in 3.1 about answering one's wife's question about her weight even fall within the bounds of "have a high relevance/effect (e.g., economic, scientific, strategic, societal, existential, pivotal, etc.... ) in human existence"..?

I was excited by the buildup and the link between philosophy and math, but the publication seems terribly hobby-ist and lacking of peer-review.

baalimago··on OpenTelemetry for Go: Measuring overhead costs
What's the performance drop on Prometheus?
baalimago··on Rust compiler performance
>what exactly is the problem with the current organization structure that would prevent any "grand" issues like these?

Well, it's summarized quite well here:

>"Performing large cross-cutting changes is also tricky because it will necessarily conflict with a lot of other changes being done to the compiler in the meantime. You can try to perform the modifications outside the main compiler tree, but that is almost doomed to fail, given how fast the compiler changes8. Alternatively, you try to land the changes in a single massive PR, which might lead to endless rebases (and might make it harder to find a reviewer). Or, you will need to do the migration incrementally, which might require maintaining two separate implementations of the same thing for a long time, which can be exhausting." - OP

A rigid organizational form (such as a company) can say: "Okay, we'll make an investment here and feature freeze until the refactors are done". I have a hard time seeing how the open source rust community who are doing this out of passion would get on board on such a journey. But maybe, who knows! The 'compilation people' would need to not only refactor to speed up the compilation times, they'd also need to encourage and/or perform refactors on all features being developed 'on main'. That, to me, sounds tedious and boring. Sort of like a job. Maybe something for the rust foundation to figure out.

baalimago··on Rust compiler performance
>But we need more people to work on them.

That's my point: I don't see how there could be people dedicated to work on an issue as grand as this in Rust's current organizational form. Especially considering all the gotchas, and continuous development of 'more fun' things (why work on open source if it's no fun?). That's why it's 'the bedrock'.

To do something like that, Rust would need to be forked and later on rewritten with optimizations. But by then it wouldn't be "Rust" anymore, it would be a sibling language with rusty syntax. Rust++, perhaps.

baalimago··on Rust compiler performance
Why haven't Rust been forked by some bigger company, who have the time and resources to specialize it into something which fits better into a professional market? Yes I'm saying low compilation time -> high development RTT is a requirement for the professional market.
baalimago··on Rust compiler performance
Seems to me that Rust has hit bedrock.

If there's no tangible solution to this design flaw today, what will happen to it in 20 years? My expectation is that the amount of dependencies will increase, as will the complexity of the Rust ecosystem at large, which will make the compilation times even worse.

baalimago··on Show HN: A MCP server and client implementing the latest spec
The fact that this is an achievement is a testament to how bloated the MCP protocol/spec already is.

Will be interesting to see how many days it'll take before the implementation no longer is the latest

baalimago··on A practical guide to building agents [pdf]
I tried doing LLM-based tests, coined it "agentic-tests" and it worked quite well:

The idea was to use Stagehand [1] as the testing framework and then integrate this with Linear, which is our ticketing system. During a hackathon I whipped something together: first the 'agent' read a UAT from linear, then it pass this into a quite heavily prompted Stagehand. The prompts instructed Stagehand to run the UAT after its best ability and make very structured notes on each step on what failed. Once the Stagehand process was done, 'the agent' reported which steps succeeded and failed and into Linear.

Fundamentally the idea was sound, but there were some limitations in both the Linear SDK and in Stagehand. With some better tooling (or a novel system) and I predict this sort of agentic testing will work very well, especially for exploratory testing where the agent may be prompted to act like either a 90 year old grandma or 16 year old turbogamer. Privacy-safe usage heatmaps may also be generated automatically to test out the UX, as each run yielded slightly different approaches to achieve the UATs.

Testing teams need not apply!

[1]: https://www.stagehand.dev/

← PreviousPage 7 of 13Next →