zby

If USDT gets to a frozen list - that means that Tether does not need to comply with requests to convert it into USD? I guess this is very useful for Tether and the other stable coin emitters.

Yeah - it depends on the frequency. I think the other guy is right that when it happens with low frequency then calling it 'context poisoning' makes sense - because cleaning the context mostly fixes it. I still would be very careful about using it - because it might be interpreted as if the poisoned context was the root cause - it might be a cause for the downstream processing - but it itself is caused by something else - so it will recur.

And apparently I am repeating here what I already have in my KB: https://zby.github.io/commonplace/theory/llm-generation-rela... - I borrowed the model from Boretti. The agent says that the note is much more careful and better developed than my comment above. You can judge yourself - but I think it does have many more details and hopefully most of these details are the good kind of filling in - but I guess it might be harder to read.

My model is about gaps - all ideas start with gaps. LLMs can fill in these gaps quickly - but some ideas are just bad - so the filling in does not improve them. Maybe it would be useful to treat that filling in as a kind of hallucination - the LLM trying to meed impossible requirements. But on other cases the ideas are good and the LLMs fill in the gaps in the right way. It is a kind of skill to see when LLMs are hallucinating in the gaps. I use LLMs very extensively and I am adding checks to that should catch when the filling in is weak - but it is still not fully autonomous.

I also try to keep the llm-enhanced (or even fully llm-generated) content separate from my human writing - because it is true that the failure modes are different. But think LLM writing might be useful even if it is not consumed directly - it can enhance LLM answering your questions.

My point is that calling it context poisoning is confusing because of two things. First - it is hard to establish how causal it is for the downstream. Second - cleaning the context would not fix it - because it would be poisoned on next round - you need active measures to fight it.

It is also a bit tongue in cheek - if you did not notice - because of course all of this can be explained if needed even if the name alone suggests something else.

"iced tea" in context was a symptom - it might influence the downstream - but it is hard to establish that. The root problem was in weights - naming it 'context poisoning' is poisoning our reasoning context :)

  > Several times, Gemini 2.5 became convinced it needed to get tea, even though it 
  > was playing the older game. The tea task for FireRed was in its weights, so it 
  > poisoned its context. It spent hours trying to find or give the guard tea. Once 
  > it had been added to its to-do list, the model could not get past it.

I don't understand why this is called context poisoning when the information was in the weights

There is now a general consensus that agents should retain everything - but project from that retained state into more useful representations for each type of work. Your approach is good for creating evidence for all of the decisions - but the retained records will probably be too detailed as the main source for agents working in bigger or older repos. We need multilayer approach for this - but I am still not sure what it should be.

Here is a comparison of ADR4All and my approach (which I am now revising): https://zby.github.io/commonplace/work/decision-lifecycle-ev... - it lives in the whole workshop for revising my approach: https://zby.github.io/commonplace/work/decision-lifecycle-ev...

I wish someone applied this as being ambitious about the quality of code.

'instructing a machine' is programming - how about this?

Product managers did not write instructions to a machine.

It is all about definitions. Writing instructions for llms is a new activity and we can call it as we wish - but I like to think about it as a new type of programming language instead of thinking about it as something completely new, because many analogies do transfer and you can use them to reason about larger systems composed of prompts. It is after all a way to instruct a machine.

There are differences and the article highlights some of them - but there are difference between programming in a functional language and an imperative one, there are differences between programming for a RISC machine and a CISC machine, there a lots of different semantics that programming languages support. Now we have a language with underspecified semantics.

IMHO instructing llms is programming - the analogy is not perfect but it is so close that it is quite useful. Programming is instructing a machine. We have now two types of programming - the traditional one that follows strict semantics and the new way of programming by prompting. The article still holds by showing the limitations of this new kind of programming.

I don't know - all of these cache hit rate advocacy is kind of goodhearting. Cache hit rates are less important than the accuracy of LLM answers and people seem to forget about it. For example I've seen articles how sub-agents poison the cache. Sure you can fill up your context with irrelevant data to have high cache hit rate - but that degrades the LLM work - sub-agents are about providing the LLM with a clean context - just the information needed to do its job, no distraction.

All of the main providers now offer cache management that can work with sub-agents - but it was kind of bolted on - and all of them have different apis - so nobody uses them anyway.

RSI is about turning that extra computation into acceleration - that is applying the compute to the (useful_work / compute) factor - this is the recursive part.

This is not a fad - this is a consequence of the Bitter Lesson. RSI is the only game in town now.

This is a hard question - but less overall deaths is more important than the correct punishment.

Humans don't use command line lsp tools - why should agents use them?

I use lsp when it is integrated in the IDE - but I haven't seen yet any usable command line tools - even if theoretically it would be very useful to type 'lsp-python -replace-function-name foo bar'.

Here is a realisation from my recent work: it is not if the data is relational - because if you need you can always push the data into relations - just like you can push it into hierarchies if all you have is files and directories. It is about how much churn there is in the relations. You can model relations with just links or something and if there is not much churn you can keep it in git and it will work OK - the problem starts when your relations start churning (like when you have reviews that need to be updated on both review instruction change and document change) this is when you see yourself start building a relational db (badly).

I am still impressed by QubesOS track and I use it for my dedicated 'financials' laptop.

IMHO the thing that is holding back QubesOS is the lack of hardware acceleration for graphics - maybe now when dual monitor setups are getting popular this could be a workaround for the security considerations?

In the age of LLMs it is important to have vocabulary that survives when taken out of context - German nouns fit that very well. In my own project I decided to use phrases of two words (often with a hyphen) for all technical terms (terms that have special meaning in my project).

And by the way I also started using Auftragstaktik as an anchor for a methodology of writing plans and prompts.

It is an interesting subject - but so much have been written about it in the past. I would like to read what are the new angles.

And for the past discussions see:

HACKER NEWS DISCUSSION LINKS

THE GERVAIS PRINCIPLE

* The Gervais Principle Main Submission (October 2009) https://ycombinator.com

* The Gervais Principle, or the Office According to "The Office" (August 2024) https://ycombinator.com

MORAL MAZES

* Moral Mazes: Bureaucracy and Managerial Work (February 2020) https://ycombinator.com

* Moral Mazes and Emotional Labor Comment (October 2019) https://ycombinator.com

MEDITATIONS ON MOLOCH

* Meditations on Moloch Systems Discussion (April 2019) https://ycombinator.com

* Meditations on Moloch Main Discussion (March 2023) https://ycombinator.com

* Context from Scott Alexander's Blog (June 2025) https://ycombinator.com

THREADS INTERSECTING MULTIPLE CONCEPTS

* Best books for dealing with workplace politics and dishonesty? (December 2020) https://ycombinator.com

* Analysis comparing Gervais Principle to Moral Mazes (April 2023) https://ycombinator.com

* Ask HN: Stories of political intrigue in large companies (December 2023) https://ycombinator.com

* Things I want to say to my boss (December 2025) https://ycombinator.com

Advertising has a positive function - currently we don't have better (market based) was to make it working other than via paid advertising. The first step is to find the new business models.

Do you have the same feeling when you chat with AI?

I think it is now or close to now - and not because there is no more to be gained - but rather because it is now clear that you can gain more with the right agent environment.

But benchmark saturation is also something to account for.

to be frank - mostly because they are now good enough to unlock the other learning paradigms

I know it is overused on tweeter - but all this really seems to be about status. Like Robin Hanson said - people read stuff because it seems prestigious.

IMHO training weights has peaked and now it is time for a training paradigm for prompts and code. We don't have the gradient descent here - but I think it can be more sample efficient because causal theories can be better than just correlations.

I am working on a unified theory in https://zby.github.io/commonplace/ - it is all agent edited so it might be hard to read, but hopefully we are catching most logical errors. Some day the llm prose will improve.

I have even a preliminary theory on what is needed for the positive feedback loop: https://zby.github.io/commonplace/articles/reflective-self-i... - (this is not stable yet - but I think you can give it to your agent to read :).

It's a pity that the Perl6 saga killed the new regex ideas - I wish the raku regexes were adopted elsewhere (like the Perl5 regexes were): https://docs.raku.org/language/regexes

There are programs with proofs that they work - but that does not make them reducible.

I double checked it with ChatGPT if anyone is interested in more details: https://chatgpt.com/s/t_6a6883385ab481919126c7b631000815