Is there anything more concrete than that? Large wins on their own aren't meaningful if they aren't good risk adjusted trades or repeatable. I've made big wins but I don't consider myself a good trader.
>Traders following the investments disclosed by Scion’s over the last 3 years (between May of 2020 and May 2023) would have made annualized returns of 56% according to an analysis by Sure Dividend
Seems like Scion Capital could have just disclosed winning trades, that they may or may not have made?
I used AI to deal with customer support when a company tried to assign me the rental contract from the previous owner. ChatGPT correctly quoted the relevant Ontario Consumer Protection Act sections that applied. I just did quick verifications to make sure it wasn't hallucinating (it didn't). They tried to push back, but I had ChatGPT write a few responses standing first and they relented after a few exchanges.
That makes sense. But then the idea of a simultaneous failure preventing, say AWS and GCP/Azure, from restarting due to accidental circular dependencies in the init sequence needed to reboot the two competing cloud infrastructure is interesting.
The big issue I have with this experience is that you don't get a clear charge price before you leave. So you have to check a page either some minutes or hours later and hope that the total is correct. Like the article said, I don't love the idea of being charged for 3 overpriced bottles of water when I only took two. I'd rather just settle my transactions in the moment than try to remember what my total was and dispute things later from memory on the occasional times it's wrong.
> you don't get a clear charge price before you leave. So you have to check a page either some minutes or hours later and hope that the total is correct
Oh, I’m very much sure this is a feature. Because, you see, only some percentage of people will actually look at the receipt. Some fraction of them will notice the error. Some fraction of those people will actually be motivated to spend their time on the phone clawing back an extra $8 water. The complement of that small percentage is a lucrative chance to sell the same overpriced water more than once.
> The person in front of me bought two items and saw she got charged for three. Since there were no paper receipts, she took a photo of the machine before going to the guest services to complain. I missed ten minutes of the game getting water.
I wish payment processors / consumer protection would have a significant penalty for sloppy overcharges. I've had to deal with sloppy overcharges like this (one for over $1,000) and you lose a lot of time and the outcome is just 'oppsies, my bad'. There's very little repercussion for sloppy overcharges so it's easy for them to perpetuate.
Back in the olden times overcharging like that would be dealt with the same way as theft would. I'm not entirely convinced it's the wrong way to go about things. It's how the concept of a bakers dozen came to be. Better give everyone 13 in a dozen, just in case you ever miscount.
I have a very similar experience. I was heavily invested in Anthropic/Claude Code, and even after Sonnet 4.5, I'm finding that Codex is performing much better for my game development project.
I got my environment working well with Codex's Cloud Task. Trying to same repo with Claude Code Web (which started off with Claude Code CLI mind you), and the yarn install just hangs with no debuggable output.
I think that's the real issue. If the LLM spends a lot of context investigating a bad solution and you redirect it, I notice it has trouble ignoring maybe 10K tokens of bad exploration context against my 10 line of 'No, don't do X, explore Y' instead.
I think the general term for this is "context poisoning" and is related but slightly different to what the poster above you is saying. Even with a "perfect" context, the LLM still can't infer intent.
that's because a next token predictor can't "forget" context. That's just not how it works.
You load the thing up with relevant context and pray that it guides the generation path to the part of the model that represents the information you want and pray that the path of tokens through the model outputs what you want
That's why they have a tendency to go ahead and do things you tell them not to do..
also IDK about you but I hate how much praying has become part of the state of the art here. I didn't get into this career to be a fucking tech priest for the machine god. I will never like these models until they are predictable, which means I will never like them.
This is where the distinction between “an LLM” and “a user-facing system backed by an LLM” becomes important; the latter is often much more than a naive system for maintaining history and reprompting the LLM with added context from new user input, and could absolutely incorporate a step which (using the same LLM with different prompting or completely different tooling) edited the context before presenting it to the LLM to generate the response to the user. And such a system could, by that mechanism, “forget” selected context in the process.
Yeah I start a new session to mitigate this. Don’t keep hammering away - close the current chat/session whatever and restate the problem carefully in a new one.
I've had great luck with asking the current session to "summarize our goals, conversation, and other relevant details like git commits to this point in a compact but technically precise way that lets a new LLM pick up where we're leaving off".
The new session throws away whatever behind-the-scenes context was causing problems, but the prepared prompt gets the new session up and running more quickly especially if picking up in the middle of a piece of work that's already in progress.
Wow, I had useless results asking “please summarize important points of the discussion” from ChatGPT. It just doesn’t understand what’s important, and instead of highlighting pivoting moments of the conversation it produce a high level introduction for a non-practitioner.
Honestly, I just type out something by hand that is roughly like what I quoted above - I'm not big on keeping prompt libraries.
I think the important part is to give it (in my case, these days "it" is gpt-5-codex) a target persona, just like giving it a specific problem instead of asking it to be clever or creative. I've never asked it for a summary of a long conversation without the context of why I want the summary and who the intended audience is, but I have to imagine that helps it frame its output.
There should be a simple button that allows you refine the context. A fresh LLM could generate a new context from the input and outputs of the chat history, then another fresh LLM can start over with that context.
You are saying “fresh LLM” but really I think you’re referring to a curated context. The existing coding agents have mechanisms to do this. Saving context to a file. Editing the file. Clearing all context except for the file. It’s sort of clunky now but it will get better and slicker.
That's not how attention works though, it should be perfectly able to figure out which parts are important and which aren't, but the problem is that it doesn't really scale beyond small contexts and works on a token to token basis instead of being hierarchical with sentences, paragraphs and sections. The only models that actually do long context do so by skipping attention layers or doing something without attention or without positional encodings, all leading to shit performance. Nobody pretrains on more than like 8k, except maybe Google who can throw TPUs at the problem.
"that's because a next token predictor can't "forget" context. That's just not how it works."
An LSTM is also a next token predictor and literally have a forget gate, and there are many other context compressing models too which remember only the what it thinks is important and forgets the less important, like for example: state-space models or RWKV that work well as LLMs too.
But even just a the basic GPT model forgets old context since it's gets truncated if it cannot fit, but that's not really the learned smart forgetting the other models do.
You can rewrite the history (but there are issues with that too). So an agent can forget context. Simply dont feed in part of the context on the next run.
Relax friend! I can't see why you'd be peeved in the slightest! Remember, the CEOs have it all figured out and have 'determined' that we don't need all those eyeballs on the code anymore. You can simply 'feed' the machine and do the work of forty devs! This is the new engineering! /s
It seems possible for openAI/Anthropic to rework their tools so they discard/add relevant context on the fly, but it might have some unintended behaviors.
The main thing is people have already integrated AI into their workflows so the "right" way for the LLM to work is the way people expect it to. For now I expect to start multiple fresh contexts while solving a single problem until I can setup a context that gets the result I want. Changing this behavior might mess me up.
A number of agentic coding tools do this. Upon an initial request for a larger set of actions, it will write a markdown file with its "thoughts" on its plan to do something, and keep notes as it goes. They'll then automatically compact their contexts and re-read their notes to keep "focused" while still having a bit of insight on what it did previously and what the original ask was.
Claude Code has /init and /compact that do this. It doesn’t recreate the context as-is, but creates a context that is presumed to be functionally equivalent. I find that’s not the case and that building up from very little stored context and a lot of specialised dialogue works better.
> rework their tools so they discard/add relevant context on the fly
That may be the foundation for an innovation step in model providers. But you can achieve a poor man’s simulation if you can determine, in retrospect, when a context was at peak for taking turns, and when it got too rigid, or too many tokens were spent, and then simply replay the context up until that point.
I don’t know if evaluating when a context is worth duplicating is a thing; it’s not deterministic, and it depends on enforcing a certain workflow.
So this is where having subagents fed specific curated context is a help.. As long as the "poisoned" agent can focus long enough to generate a clean request to the subagent, the subagent works posion-free. This is much more likely than a single agent setup with the token by token process of a transformer.
The same protection works in reverse, if a subagent goes off the rails and either self aborts or is aborted, that large context is truncated to the abort response which is "salted" with the fact that this was stopped. Even if the subagent goes sideways and still returns success (Say separate dev, review, and test subagents) the main agent has another opportunity to compare the response and the product against the main context or to instruct a subagent to do it in a isolated context..
Not perfect at all, but better than a single context.
One other thing, there is some consensus that "don't" "not" "never" are not always functional in context. And that is a big problem. Anecdotally and experimental, many (including myself) have seen the agent diligently performing the exact thing following a "never" once it gets far enough back in the context. Even when it's a less common action.
Not that this shouldn't be fixed in the model, but you can jump to an earlier point in claude code and on web chat interfaces to get it out of the context, just sometimes you have other important stuff you don't want it to lose.
The other issue with this is that if you jump back and it has edited code, it loses the context of those edits.. It may have previous versions of the code in memory and no knowledge of the edits leading to other edits that no longer align.. Often it's better to just /clear.. :/
IMO specifically OpenAI's models are really bad at being steered once they've decided to do something dumb. Claude and OSS models tend to take feedback better.
GPT-5 is brilliant when it oneshots the right direction from the beginning, but pretty unmanageable when it goes off the rails.
Did you attach the debugger and see what it was crashing on?
From when I used to work on performance and reliability at Mozilla, these types of user specific crashes were often caused by faulty system library or anti-virus like software doing unstable injections/hooks. Any kind of frequent crashes were also easier to reproduce and as a result fix.
I understand this might seem unlikely given that it's working fine as 64-bit, but that crash dump makes me want to suggest running a memory tester. It has "Possible bit flips max confidence" of 25%. Ignore the exact percentage, I don't think it means much, but nonzero is atypical and concerning. (Definitely not a proof of anything!)
"It would crash in random spots" is another piece of evidence. Some legitimate problems really do show up in a variety of ways, but it's way more common for "real" problems to show up in recognizably similar ways.
And having a cluster in graphics stuff can sometimes mean it's triggered by heat or high bus traffic.
I'll admit I'm biased: I work at Mozilla, and I have looked at quite a few bugs now where there were good reasons on the reporter's side as to why it couldn't possibly be bad RAM, and yet the symptoms made no sense, and it ended up being bad RAM. Our hardware is surprisingly untrustworthy these days. But I also happen to be working on things where bad RAM problems are likely to show up, so my priors are not your priors.
hm. would be nice to have one of the traces with egl disabled. but I guess this is not really my problem to debug, esp since it's such an edge case (32 bit on 64 bit machine + nvidia blob) and given mozilla is abandoning support anyway.
