1,295 karma · joined July 16, 2017
https://github.com/baalimago https://lorentz.app
"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.
> HN: No thanks!
> User: vibe coded script... with AI?
> HN: Oh boy, now we're talking..! Upvote, upvote..!
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
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.
Will be interesting to see how many days it'll take before the implementation no longer is the latest
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!