amdivia

The following paragraph is extremely emotional.

I think the whole industry is heading in the wrong direction. And it really frustrates me that most LLM coding agents are based on excessive delegation (or at least promoting it), which for me, is what causes the difficulty in entering the flow state. (I think the slow generation speed of SOTA frontier model labs also contributes to it, 30 seconds to generate something simple is a lot of time, but that's a different discussion)

We must kill excessive delegation. Our LLM coding tools should be built incapable of performing it.

Imagine if you have a coding agent where if you tell it "create a simple Todo app" it will fail telling you "simple Todo app is undefined", requiring to provide a more comprehensive descriptive prompt of what you want, then, this longer prompt becomes where your flow state functions, you are describing your edits and code in a more fluid way but still in text, and your focus becomes on this description/specification that you'll feed to the LLM.

(can't edit the above but for future references, this doesn't seem to be by Edward Fredkin, and I couldn't find "The intelligent machine" as the article states

Still, this is a pre-LLM era copy-pasta it seems, and the idea within it is still relevant)

The.. false positives are extremely scary (not listed as hallucinations)

A terrorist on the US saction list.. the first female airplane suicide bomber?? I was in the US a year ago and I did not bomb any planes

I think with Arabic names it's highly biased, which is kind of scary, I don't want to be bombed based on an LLM query

110+ Tok/s as another data point on the RTX 5090 (Gemma 4 31B QAT + MTP at UD-Q4_K_XL) (at peak used 27 GB of vram)

The real lovely thing was getting 300+ Tok/s (Gemma 4 26B QAT + MTP at UD-Q4_K_XL) (at peak, I think I saw vram usage reach 21 GB of vram)

This was once attempted, and in a way such that each letter needed only one character no matter it's position in the word

Unfortunately it died

https://worksthatwork.com/6/unified-arabic

Aren't there immense security risks when the model is allowed to deceive even if it was for "good"?

Reminds me of an excerpt from Edward Fredkin's "The intelligent machine" [1]

https://noor.imx.sh/2017/09/30/when-they-communicate-they-co...

I think they'll be extremely worse on their own

Predicting "America" in "The United States of ..." Is a different task from predicting the whole sentence.

So the small model is laying the blocks, and the bigger model would be cementing them in place or kicking them down. The bigger model's course correction is what keeps the smaller models predictions relatively on track

I mean,

"Give me a Todo app"

Is also different from

"Write a function that takes a string parameter (Todo) and saves it into a text file with the name <current date time (as a Unix epoch)>.txt, and if already present, append to it to the file instead"

The probability distribution for the potential output is different, and it's more limited in the second case perhaps.

Besides, even the "deterministic" systems the author is referring to, are not fully deterministic. They are "deterministic" if we ignore a certain threshold of randomness that could afflict the system. Yes perhaps this threshold is higher when using LLMs, but even when using LLMs, not all inputs share the same level of indeterministic output

Or v for those using bash's vi mode

Reminds me of Chesterton's fence [1]:

"In the matter of reforming things, as distinct from deforming them, there is one plain and simple principle; a principle which will probably be called a paradox. There exists in such a case a certain institution or law; let us say, for the sake of simplicity, a fence or gate erected across a road. The more modern type of reformer goes gaily up to it and says, "I don't see the use of this; let us clear it away." To which the more intelligent type of reformer will do well to answer: "If you don't see the use of it, I certainly won't let you clear it away. Go away and think. Then, when you can come back and tell me that you do see the use of it, I may allow you to destroy it.""

[1] https://en.wikipedia.org/wiki/G._K._Chesterton

Also what people forget, even read access alone can be used to communicate with an attacker.

Assume locally i know a read only agent (running on account A) is reading a specific file from user B. Assume it has access to a secret that user B cannot observe. By prompt injection, you can have the read only agent encode the secret as "read" pattern that user B can decode by looking at file access times.

(You can think of fetch requests and the likes for more involved cases)

So read only, while helpful, does not innately prevent communication with an attacker

Exactly!!

I've been trying to work on a new LLM code editor that does just that. When you instruct it to do something, it will evaluate your request, try to analyze the action part of it, the object, subject, etc, and map them to existing symbols in your codebase or, to expected to be created symbols. If all maps, it proceeds. If the map is incomplete, it errors out stating that your statement contained unresolvable ambiguity

I think there is a real benefit here, and it might be the actual next beneficial grounded AI sustainable use in programming. Since I the current "Claude code and friends" are but a state of drunkenness we fell into after the advent of this new technology, but it will prove, with time, that this is not a sustainable approach

Until we have breakthroughs in homomorphic encryption compute, I won't trust such privacy claims

My main gripe with tmux is the nested use case (tmux session on my local machine, in which I ssh to another machine, only to tmux attach within the remote machine too). Is there a terminal multiplexer/session daemon that supports nested sessions out of the box with ease?

Advertisement in my opinion, trying to latch on Sci-fi tropes

Assuming Claude Code was used. If OpenCode or some other programmatic method was used, the "fake tool calls" won't be added

Btw seems like NullClaw is facing the same issue. Currently the 1st result on Google is a shady website with popups, claiming to be NullClaw's (while the actual site (nullclaw.io) is not coming up

This seems to be a pattern

I'm yet to find a satisfying vim AI integration. I want something that blends into my vim workflow, and does not require me to switch Windows and copy paste or reload my open buffers after AI agents edit my code.

For instance I would love for it to seamlessly melt into a "highlight comments/pseudo code" -> some keybind, then AI would expand those to actual code for instance, or I don't know.. but something not like what we have currently

I found this to be inaccurate, I can run OSS GPT 120B (4 bit quant) on my 5090 and 64 ram system with around 40 t/s. Yet here the site claims it won't work

Exactly, that's why I objected to the "noble" aspect of working on defensive technologies

Although I agree with the general sentiment, but I'll slightly push back on the "nobility" of any engineering pursuit. Such things are highly amoral (not immoral) and context specific

Assume an "Evil" state worked on defensive technology that can foil any nuclear attacks against it. Now, this allows this "Evil" state to use it's own nuclear weapons without fear of retaliation. So in this example the innovation made in defensive technologies allowed for war and destruction

I'm waiting for someone to polish a well thought out interface for power coding

Seems very interesting thanks for sharing! (even tho it still has a review process, but I feel it's heading in the right direction)

I think for AI to become useful while minimizing it's harm, the interface as a whole needs to be reworked. Instead of having a loop of code generation followed by review. The initiative should be taken by the developer, AI should be a background thing, not one that's surfacing itself to the developer.

For instance I was thinking of AI coding where the developer is writing the application interface, files, design, and the AI in the background is reading them and translating them to the programming language of choice.

This way the developer is writing the whole thing out by hand, it would be as if one is writing fluid pseudo code, but the abstractions would be there, the way they are interacting with each other is there, the human is thinking if the abstractions and when to use them. Whereas the AI is out of the view, simply translating the fluid pseudo code to a rigid programming language.

Perhaps the above isn't really it, but I strongly feel something needs to change in the way we currently work, because it really creates a chasm between the developer and the outputted code not only in terms of the actual implementation but the mental abstractions it's supposed to reflect

I mean he still does say "and ship it as your own" and he mentioned plagiarism too, all of which made me perplexed initially

I'm failing to understand the criticism here

Is it about the haphazardous deployment of AI generated content without revising/proof reading the output?

Or is it about using some graphs without attributing their authors?

if it's the latter (even if partially) then I have to disagree with that angle. A very widespread model isn't owned by anyone surely, I don't have to reference newton everytime I write an article on gravity no? but maybe I'm misunderstanding the angle the author is coming from

(Sidenote: if it was meant in a lightheaded way then I can see it making sense)

The thing is, in this context "editing text" is seen as the one job, that one tool should do.

So when you're working with multiple applications, all of which are trying to force you to use their own way of editing text, it feels highly fragmented and un-unixy

I do understand what you're saying, it's just that I wish the text editing portion of most of these tools is abstracted to a degree that allows for my text-editing tool of choice to be used within it

Side question: does anyone else feel like the quality of openclaw (as a tool) is extremely low?

Their logging seems to be haphazardous, there is no easy way to monitor what the agent is doing, the command line messages feel unorganized, error messages are really weird.. as if the whole thing is vibe coded? not even smartly vibe coded..

Even the landing page is weird, it takes one first to a blog about the tool, instead of explaining what it is, the getting started section of the documentation (and the documentation itself feels like AI slob)

Some ideas:

* Clear labeling of action types (read/get vs write/post) * A better way of describing what an agent is potentially about to do (based purely on the functions the agent is about to call) * More occurrences of AI agents hurting more than helping in the current ecosystem

Feels AI-ish as well, and OP used em-dashes in some of their replies. But it could be attributed to a language barrier of sorts requiring the use of LLMs to communicate