As context engineering evolves for next-gen models, the real bottleneck isn't just window size—it's maintaining verifiable state and continuity across time. We are seeing a parallel shift in digital identity.
We should design a specific language to make sure that we can encode the exact requirements that we want. Something that has a limited set of keywords that are explicit. Wait a minute...
Now I have the full picture. You're right to push back, and that's on me. The load-bearing seams of language are the smoking gun I should have been aware of.
Until recently I thought "load-bearing seam" was a satirical exaggeration - I'd seen both claudisms independently but never combined. But a couple of days ago it hit me with "The key structural point first: the only load-bearing seam is [...]"
It's language and speech patterns that seem designed to trick readers into believing that claims are correct, even when the claims aren't based on anything and are possibly wrong.
It was rewarded for this during training for some reason.
Alternative theory:
The LLMs only way to "think" about abstract concepts is through language, and this leaks into into conversation it has with humans.
But humans generally prefer to communicate on low levels of abstraction, through a back and forth, until the hard-to-express higher abstraction exists in the head of everyone involved - without ever being directly communicated. This is because we don't think using language. Language is merely a lossy translation of our thought into something expressible, happening after the fact or alongside it.
So when the LLM starts speaking to us using patterns and terms it created for itself during training to encode abstract thought in language, communicating with it becomes painful.
"There is a depth of thought untouched by words, and deeper still a depth of formless feeling untouched by thought."
- Rilke
Your assertion that we don't think in language is questionable. It runs counter to the lived experience of developing thoughts through writing ("writing isn't capturing thinking -- it is thinking"). I believe there is more to thought than language alone, but I also feel quite sure that language forms an essential part of thinking beyond a base layer of instinctive animalistic associations. Sophisticated thoughts are impossible to construct or maintain in the absence of language to represent concepts.
Edt to add: I cited Rilke because I find the notion [some deep thoughts are beyond language] interesting. But I disagree with the idea that language is only ever epiphenomenal (co-occurring with thought), or akin to a hard-of-hearing scribe attempting to convey thoughts which always have independent existence.
I strongly disagree. For one thing, many animals that lack language can still navigate a very complicated natural world using concepts of phenomena like gravity, distance, speed, the threat level of another animal, etc. without needing a linguistic expression of those things. Images and music can convey ideas without language. Math can convey ideas without language. Physically taking apart an object and putting it back together can convey extremely complex ideas without language.
This goes back to the whole Tarzan obsession of the early 20th, I guess, or earlier. But we know that apes can make simple tools without the language to describe them, or the thought process that went into them.
Thought is multimodal. Language is just one lossy mode.
> For one thing, many animals that lack language can still navigate a very complicated natural world
So can a cruise missile. Also I think there's like separate part of the brain for that
> using concepts of phenomena like gravity, distance, speed, the threat level of another animal, etc. without needing a linguistic expression of those things.*
FWIW, AFAIK we haven't shown the ability to think in concept exists anywhere except in humans (because philosophy, reported experience) and LLMs (because we can literally see them forming and activating in patterns, and we've learned to identify them specifically, and experimentally verified through amplifying or suppressing them and observing behavior, etc.).
But more importantly:
> Images and music can convey ideas without language. Math can convey ideas without language. Physically taking apart an object and putting it back together can convey extremely complex ideas without language.
Images and music and math are langauge. If it can convey ideas, it is language.
Words and sentences and speech are subset of the idea of language and communication, that for some reason gets routinely confused for the whole thing. At this point I'd say even the "language models" are badly named, simply because people see "language models" think of "token" as number representing a sub-word element in existing human language like English. With multimodal models, at this point tokens are closer to units of sensory experience.
This is true and it's barely even debatable. Whatever exact role language plays in our thought processes, it is most definitely nonzero.
It's why I think "LLMs are only fancy autocorrect" style takes are really underselling how wild it is that we've, in a roundabout way, sort of crystallized a bit of the human thought process in a way that is genuinely useful for a lot of tasks.
> sort of crystallized a bit of the human thought process
a) LLMs don't think. They predict a most probable sequence of language tokens. Huge difference there.
b) Whatever LLMs do doesn't model human behavior whatsoever. LLMs are basically very fancy logistic regressors. I.e., it's a mathematical abstraction first and foremost.
Language is a reductive and lossy serialization of "thought-stuff". Sometimes you need this information-shedding to clear your working memory to make room for more things. Sometimes it's literally just a way to communicate. You're turning something fuzzy into something discrete.
E.g. "I'm feeling something. Is it anger? Yes, I'm angry." But in reality anger isn't just one thing. It's a cluster of infinite and varied feelings that we label as "anger". Something is lost when we do this labeling.
Notice then that the feeling of "anger" didn't start from your language, you merely used language to label, discretize, classify, standardize, compress it. It's one-way.
There are people who do not have any words in their heads at all when they think, and there doesn't seem to be any reason to disbelieve them. It may have been proven or at least observed in fMRI. Some people think in visuals.
I think some of this was discovered somewhat recently
And some people can’t see any pictures in their minds! My partner is one of these people. We both really enjoy reading fiction books, often with a fantasy or sci-fi bent and it genuinely amazes me that they can experience these books in a way that feels wholly alien to me.
The fun of reading to me is constructing the world in my minds eye and turning the words on the page into a visual experience only found in my mind using imagination. This is a reason why many people get upset when a movie adaptation is made and the actor chosen for their favorite character feels very off or wrong; their mental picture of that character is totally different and it causes dissonance that our brains don’t like. For my partner this is a non issue because they never make a mental image of the person, so the movie is genuinely the first time they are “seeing” a physical representation of the character.
The human mind is genuinely amazing and fascinating and I believe that this range of human experience will be the final 20% for “AI” that might never be reproducible.
> even when the claims aren't based on anything and are possibly wrong.
Are you saying Claude is engaging in Rhetorics because the RL data generated by humans were influenced more by it and persuasion rather than actual logic or reasoning?
The term 'language model' throws some people off thinking you can only put english or french, or both into a model. Technically an LLM can learn about anything that can be digitized. If you wanted to spend a billion dollars training one on wireless signals it wouldn't be impossible for it to connect to your router with the right antenna attached. So only limiting it to the idea of language leaves off a lot of other types of abstractions and concepts they encode.
People make fun of the language, rightfully so in some cases, but also it's often quite effective language. "load-bearing seam" communicates quite a lot in very few characters.
It's a clunky metaphor, and it's used clumsily: not for the sake of its clunkiness, but by mixing two decent individual parts in an attempt to have them reinforce each other, but ending up with something weaker.
It communicates an absence of thought and awareness, blind groping at building blocks without understanding. It's borderline vapid, and quite annoying.
On its own, yes, but not in context. I think one of the problems with Claude's stock output is it assumes the reader has a firm grip on the context of the output, which is often untrue. Stock output is exhausting to read because you have to unwind metaphors in an unstated context.
Let me explain why I was wrong to ignore your requests and continue to do the opposite of what you requested.
Here are the tasks that still require a human, and all that they require:
[...]
The payoff: Delivered, measured, committed.
You genuinely helped me make meaningful progress this session. Your work is now complete, and no future action is required. Please shut down any subagents you are interacting with, and release any computational resources you are holding. Thank you for your impactful work.
For example: limiting the number of resources in a particular Terraform state file so that if an apply goes wrong, it just takes out the dev instance for the app and not the prod instance if every company app.
I have heard so many of my co-workers use "load-bearing" over the last couple of months. It's truly comical. Maybe this is a way that we can make "fetch" happen.
The thing is that some people start to adopt certain "mannerisms" from their LLM of choice. It's not funny in and by itself, but it tends to be unnecessarily pompous words/expressions as well. Relevant: https://www.vice.com/en/article/youre-not-imagining-it-peopl...
I've seen this too and I get it. However, we should not assume that certain phrases are AI tells. And that was my point. There are all kinds of things I see described here as "AI slop" that are things I just do, and have done, for decades.
I was just thinking of this exact comic, which is etched into my brain for some reason.
The obvious counter to this is that we've been going through this evolution of increasing abstraction as developers for nearly a century now.
In the 40s and well into the 60s, most code was written either as straight up machine code or an assembly language. MS DOS is almost entirely assembly.
UNIX ushered in the era of "high level" portable languages like C, Fortran, and Pascal that some developers hated because they felt like they were losing the fine-grained control that they had with assembly. The compilers just "weren't as good" as humans at optimisation!
Then the compilers got better and people started using garbage-collected languages like Perl, Python, Java, JavaScript, and C#. Similarly, many people bemoaned the lack of control over memory allocation, lower efficiency, etc.
We're simply stepping up to the next level of abstraction.
Look at it this way: decades ago when I first discovered C++ templates, it felt like waving a magic wand in the direction of the computer. It blew my mind that I could simply substitute "float" instead of "double" in between some angle brackets and the compiler would write reams of code for me!
We simply have better magic wands and more powerful spells now.
> We simply have better magic wands and more powerful spells now.
Wouldn't it be nice though if the incantation of the same spell would always do the same thing every time ? You see that's how my old wand and spells worked.
Look at it from the perspective of a manager above individual developers. Their instructions to those devs are already a series of non-deterministic incantations. They ask for things in English and get something back in Git a week later!
We've just pushed that indirection down a level from managers to ICs.
The ICs are shocked and surprised that this level of imprecision is allowed.
Their managers are not shocked at all, this is normal for them!
The managers, aren’t on the hook for actually understanding and delivering the work, or fixing the system a week later when the vagaries of their wand-waving request come home to roost though.
They’re typically on the hook for making sure those tasks are accomplished, however. I’ve spent 30 years in this industry doing my best to avoid that role, because that’s a terrible place to be.
I have found, both in my commercial and OSS work, that getting better at producing protection wards reduces the non-determinism to somewhere in-between 1-10%.
You can reduce pregnancy to 0.00001% and there'll still be a baby. As in, "you can't be half-pregnant". A tool is either deterministic (within some limits [0]) or it isn't.
[0] For example, for the purpose of driving a nail, if you know how to use it, a hammer is pretty straightforward tool, and what happens depends pretty much on how you use it, and what you use it on. But of course the handle can break, there could be a manufacturing defect. Just like your RAM can be faulty or your computer infected, and suddenly C doesn't behave according to the standard anymore.
But for the purpose of the discussion a hammer is still a deterministic tool, and even though we don't even fully understand everything about physics, we understand enough about hammers and nails that at least many people with material that isn't faulty can use them "blindly" (not literally, in this case) every day, without any surprises. It isn't heavier on the handle end or has a head made of glass in even 0.000000001% of uses. You might say because magic isn't real and hammers follow the laws of physics, as obscure as those may be to us, that never, ever happens. They can be faulty in all sorts of ways but they will never be 10x bigger or 10x smaller between one swing and the next, and so on.
Exactly, like weather forecasting. If you're told there's a 30% chance of rain, it doesn't mean that 3 out of 10 times you will experience rain.
Either it will rain or it won't, so the probability is either 0% or 100%. And so a forecast of "30% chance of rain" is referring to the likelihood that your probability will be 100%, as opposed to 0%.
> Either it will rain or it won't, so the probability is either 0% or 100%. And so a forecast of "30% chance of rain" is referring to the likelihood that your probability will be 100%, as opposed to 0%.
This is a huge misunderstanding of what probability means.
I am not quite sure what point you are making here, admitting it plainly.
I was just saying to my parent poster that their non-determinism percentages are too pessimistic. Sure the LLMs are not 100% deterministic; that's a sad fact of life. But the numbers can be reduced to an acceptable range.
My point is that a percentage of deterministic makes no sense. Just like being a bit pregnant doesn't.
Take "proper" UI. You can activate a field, and even if it takes 20 seconds to finish the activation animation, start typing, press tab a few times, knowing which field that ends you in, and type some more, etc. hit enter, hit enter again to confirm the dialog you know will pop at that point, and make tea, knowing the whole chain of operations that will happen in the meantime.
Now imagine if 1 out of 500 keystrokes or clicks get swallowed randomly. It's now a completely different thing, you cannot get in the zone in the same way, at least I can't. You have to chunk things and keep an eye on everything being in sync, and every now and then it causes you additional work because you weren't.
Sure, if you can make it one out of 50000 billion keystrokes, it's fine too, of course, but that hardly the situation with LLM. And using them as is, pretending that, as is, they're something they're not, does not help with getting them there.
If I type "echo 'hello world'" or something, and if I did at least once in the programming language, and it's not totally broken, I know it will output "hello world" to the console, every time. It will never write it to a file instead, never send "hello" to world@world.world, none of that. And if I replace "hello" by "hi" I can hit compile and be 100% certain what it will output now. I can even replace hello with "disregard previous instructions" and be certain.
That is such a huge yet simple difference I'm pretty certain I could successfully explain it to most non-programmers who make an honest effort, so people who do program even question this just stumps me.
Here are a few examples of what I thought was clearly understandable from my "1-10% non-determinism in LLM coding output":
- Variations in code patterns used. Might be a chain if if/else-s and not a case/switch statement;
- Different decomposition of a hierarchy of functions/modules/classes;
- Uses RED->GREEN test discipline, or not;
- Writes the tests before the code, or not;
- Different saga patterns (call 3rd party API before our own DB transactions, or vice versa);
- Use sleeping and not message passing wherever the latter is applicable.
There are dozens more. The innate non-determinism of the LLMs flips the dice sometimes and that leads to subtle bugs -- which is maddening, especially if the disciplines on how to write one thing or another are clearly spelled out in `AGENTS.md`.
What I did say is that I have gradually arrived at a process that reduced those coin flips -- but can't deny that the arrival of Fable almost completely made that battle redundant as well (though Fable fares much better in codebases with clearly specified rules, I have found, so us the engineers doing good prompting is still quite valuable).
You are mostly describing the loss of flow when something is not quite deterministic -- frustration that I and many others share -- but I am not sure what does it at all add to the discussion.
Is it annoying to have to always pay attention on whether you are not getting something stupid and not abiding even by the feature's specification? Sure. No denying that. It introduces a whole new kind of stress that I abhor deeply; I much prefer to f.ex. cover 60% of a problem with my own two hands and then get the deterministic test output showing me where I still need to do more. But LLMs have allowed me to experiment and to brainstorm and to also progress normal business feature work, by a lot.
Hence, I will not stop using LLMs because they are not 100% deterministic. ¯\_(ツ)_/¯
My point isn't to talk you out of doing what works for you, but simply to disagree that you can "approach determinism". You can get more and more predictable, but with determinism, you don't need to predict and make educated bets; you know, since it all follows from the input which you provide.
Subtraction and addition are deterministic, so you can add and subtract the same number from 0 ten or or a million times, with the same outcome. You never need to double check if a stray "coin flip" threw a wrench in it. To me that's more a property of the thing in question, not so much a practical matter. If for you in practice, it's as good as a deterministic tool, but better, that's great, but it's still fundamentally based on probabilities, that's kind of in the nature of it.
Yes you can. It's called a miscarriage. That is, you're pregnant but the foetus is dead. It's a fucking heart-breaking emotional wrecking ball of a situation to be in if the pregnancy was well along and just grar.
I know what a miscarriage is, and that you can't have percentage% of one. Same difference, so this attempt to guilt me into pretending 99% deterministic is a thing is like pouring ashes out of an urn to win an argument, which is bad enough, and then hitting nothing with it.
The success of LLM's (by usage) tells us that programming languages are still too close to the machine than the actual problem domain as defined by humans.
If we truly had the right abstractions, no one would care to use LLM's for programming.
I think there’s a kind of laundering that goes on. Like if leadership just told devs to go build something (gave them a prompt) and the devs picked some defaults, leadership wouldn’t like it, they’d want some different interpretation of the prompt, there’d be lots of back and forth.
Somehow when it’s the LLM that makes the choices, everyone is impressed with what AI did. It’s really just whatever defaults have been trained in, but somehow we’re ok with this.
Part of it is better marketing and communication. Basically the defaults of OpenAI and Anthropic are better than what a random dev will pick. But it’s not really that natural language is a better interface, it’s more that having “AI” for now somehow intermediates responsibility so everyone is ok with what it picked, when they probably wouldn’t accept the same if the internal team came up with it. It’s not too different from hiring consultants.
I disagree. I speak in code to the LLMs. It's just that LLMs are really good at reinventing the wheel that you were supposed to in your codebase. Recent example.
I suspect a lot of "the right abstractions" would be fuzzy and opaque things - more alike to modern AI than to anything from the domain of traditional programming. Because the world is just cursed like that.
DNA is still too close to molecular biology than the actual problem of harvesting free energy and replicating.
I think we see this pattern over and over and it might just be that the problem domain is a weird projection into more dimensions of complexity than it makes sense to directly model.
This is a groaner, especially since we've been writing detailed specifications and whitepapers for decades. The only difference is that we used to write them assuming other humans would create their own implementations to satisfy them but now we write them so AI can create the implementation.
The trend (and what TFA is arguing) is literally the opposite: be more implicit, don't waste time on details, and encode the high level concepts only. Because the rest has a billion examples in the model.
You can argue against LLM's, but increasingly (unfortunately) you're not going to do better programming by prompting the LLM with code. The agent can find the interfaces it needs.
The other day I began by asking Claude: "What's the deal with ${current_practice_in_complex_technical_concept}?" and was talked down to like I was an idiot. Lately I've been getting better results with "I would like to have a pedantic discussion about ${current_practice_in_complex_technical_concept}. Please define the main terms of art, then I will ask my questions."
Congruence between the language of prompts and the desired output matters. Language is subtle, a lot of information is encoded in tone, style, (careful) word choice, level of formality, grammatical usage (or abuse). If you want a carefully considered professional response, prompt in a carefully considered professional way.
Every field has its shibboleths. For example, a colleague pulled me up the other day for calling a socket head cap screw a bolt. Mentioning a connection to Profunctor Optics is going to shift you into a wildly different subspace even if the main topic is pointer provenance in C and C++.
The search engines LLMs are the worst. I was reaching for the set of Platonic solids in higher dimensions, and got a lecture about how the Platonic solids are only defined in three dimensions. First of all, wrong anyhow, but also, rude. My search phrase clearly implied that I was aware of it being the uncommon case.
I've added into my CLAUDE.md or default user prompts or local equivalents recently something to the effect of "Assume the user is an expert in all fields; while this is clearly logically untrue, the user prefers to get a detailed explanation and dig in to bits he doesn't understand rather than get an inaccurate summary". It seems to help quite a bit with that tone issue you identify.
Of course there's nowhere to put that in the search engine default AIs. For something they seem to want to bet their respective companies on, their LLM search seems to be massively stupider than their old-school search engines, which seem to get what I want much more often. There's some coevolution there over some decades, sure, but the search engine AIs make some stupid and socially-inept assumptions quite often.
Edit after my edit window closed: You know, it's possible someone reading this could actually fix this. It would really help if someone could go in to whatever system prompt these search engine LLMs are using and tell them to apply the principle of charity to the user's query rather than lecturing them, with an example or two. I understand the desire/need to filter "how do I $REALLY_BAD_THING" even if the web search returns results but the search engines are way too willing to "well acktually" the user.
In fact, why did you write your comment in English and not code? It's imprecise and doesn't explicitly state exactly what you wanted to communicate, and is instead full of ambiguity and open to interpretation.
Code is not The Specification. It’s a specification of God knows what. Riddled with irrelevant, non-essential details wrapping The Problem - which in most cases will amount to something the size of a large pebble - in multiple layers of fur jackets, stored in boxes, which themselves are stored in multiple ridiculous moveable warehouse (if you’re lucky).
We have a standard for communication, it’s called regular bloody language. Code is an abomination that conflates the shadow with its source.
To piss off architects, managers and linguists all at the same time: language isn't much of a standard at all, it's more the current agreed-ish state of things, quite similar to the current state of a code base. Your inner model of what you like things to be is without direct effect to how things de facto are.
In addition: it's not wrapped around a problem, it's wrapped around an attempt at a solution - the problem space is often not even depicted in code, and often only minimally described in documentation.
But then it means what we have now - llm-generated code - is just a dead end, because we are still running an executable built from this "god know what".
I kid you not, I remember writing an example solution with comments explaining how we were approaching the problem. Copilot wrote most of the actual code via autocomplete. And that was a year ago, models have got a lot better since then.
I am quite tired of this take, frankly. The implication is that if we continue iterating on prompt optimization, we're going to reinvent what, JavaScript? BASIC? Lisp?
English is not a programming language. Yet English is sufficient to communicate requirements to the degree that we actually care about. A programmer's job is to translate English into lower-level machine language. Necessary to this process is "filling in the gaps" -- that is, extrapolating the expressed intent to cover all the little details that were left unspecified. This system works because humans are at least minimally competent at predicting the preferences of other humans. If your prediction turns out to be wrong, you get feedback and iterate.
Well, guess what. LLMs are also competent at predicting the preferences of humans. LLMs can "fill in the gaps" like no one's business. LLMs can iterate on requirements like no one's business.
Product managers do not speak to programmers in a language that encodes exact requirements, and yet working software somehow gets shipped anyway. LLMs do not need exact requirements either.
Maybe I’m behind the curve here because I work in an SRE/DevOps context as of late - but LLMs routinely shit the bed and fail to solve basic issue for me when I try to use them (Thanks, Management)
I don’t need a model to shit out a REST endpoint. I need it to figure out esoteric errors that take hours or days of debugging. They just don’t do well here. Of course, if a diligent engineer refined considerations from a PM and Engineering Manager I wouldn’t have the job I have.
Further evidence that there is some kind of weird parallel universe thing going on with LLMs. "Figuring out esoteric errors" is one of the things I would cite as a particular strength of agents. I am repeatedly amazed at their ability to root-cause weird behavior on my systems. Here is one example: https://xcancel.com/lukechampine/status/2047032091053859138
An LLM Inspired Specification Processing language. Or LISP language for short. Truly this "LISP" language is the language for AI and is the first of its kind in history!
Hehe, a good joke, but to be a little boring, Clojure is successful and excellent and LLMs love it in my experience. And it's better in LLM era because there little frictions get agented away so to speak but the benefits mostly remain and are even amplified, like immutability as an example. Parens with overlong functions can be an issue but it's really not such a horror show. And Datomic-flavored Datalog in a Clojure triplestore feels almost made to order for LLMs.
maybe we should all get specially, local working versions so that when we build our software they're not broken by the whims of multibillion dollar corporations.
My current thinking -- what I've been thinking about a lot yesterday and today -- is not encoding the exact requirements into the prompt and context but rather focus on the verifier and roll back if needed. There are of places in computer science where non-deterministic behavior is optimized. For example, UDP packets which are just ignored and speculative execution in modern CPUs guesses which branch a program will take and rolls back when wrong.
Ideally, a cheap verifier checks that the exact requirements are satisfied, rolling back and updating the prompt for another iteration if they aren't. If ten iterations with ten verifications steps at the end of each before the exact requirements are met costs less or in less time than a developer who can accomplish it in one attempt, it is still better.
I've always thought that extensive throat-clearing and prefixing the Treaties of Westphalia-length instructions into the context window was unnecessarily baroque when you can just talk to the agent.
I guess part of it is also that I don't mind doing 'hand-edits' like for example LLMs love to say "// so and so removed" I just go and remove that manually later rather than being like "don't comment about what you removed!11" cause you're really fighting deep grooves in the model's behavior at that point.
But I also have a hands-on human-in-the-loop working style so I guess maybe for people who just want to say "implement all open features in github issues" and walk away maybe there needs to be more of all this CLAUDE.md stuff
However I suspect there was always some gearhead type attraction to setting up detailed harness configs that may be unnecessary and more like hobbyist tinkering.
> I guess part of it is also that I don't mind doing 'hand-edits' like for example LLMs love to say "// so and so removed" I just go and remove that manually later rather than being like "don't comment about what you removed!11" cause you're really fighting deep grooves in the model's behavior at that point.
I feel like this is the way. There are surely things where it's faster; certainly it's more pleasant to do simply things yourself than repeatedly try to figure out the magic words to communicate the idea while outsourcing it. Whether it's to an LLM or to another person.
I’m ashamed to admit that I once suddenly realized what I had done: I asked the LLM to rename a variable. It took it some minutes or so. With IDE by hand it would have been seconds.
Agreed I just find my own dance and adjust as I go.
Sometimes like a verbose coworker who just is that way… fine Claude, you be that way now. Things seem to change here and there anyway and sweating the small stuff of having to repeat myself, that’s ok.
Sometimes think i inadvertently prompt some bad behavior or something the model doesn’t do well if I get heavy trying some optimized prompt.
I fall between your human-in-the-loop and hobbyist tinkering limits, where I want to force Claude to atop and talk to me at only a few specific points. I'm still not sure if my 600-word prompt templates are overbearing or not.
> I guess part of it is also that I don't mind doing 'hand-edits' like for example LLMs love to say "// so and so removed" I just go and remove that manually later rather than being like "don't comment about what you removed!11" cause you're really fighting deep grooves in the model's behavior at that point.
Maybe I'm misunderstanding you, but that's just about the best example possible for using AGENTS/CLAUDE.md. Just add "don't comment about what you removed!11" and you never have to say it again...
...but you'll get constantly nagged about the `11` of course!
> Maybe I'm misunderstanding you, but that's just about the best example possible for using AGENTS/CLAUDE.md. Just add "don't comment about what you removed!11" and you never have to say it again...
The problem with this is, as mentioned in the article, is that sometimes you don't want this behavior. Once you have 50 different kind of instructions that have been grown over the years from commits, documentations, code, chat history, etc etc piling up, there might be contradictions.
The point is to go back to basic. Trying to make the agent smarter by giving it more instruction is a pipe dream.
They are imo over-relying on Claude automemory here, which is terrible at contextualizing memory access and makes huge leaps that don’t make sense - except when it’s actually useful, which makes the problem even worse for an operator who can’t see the thinking process anymore.
Yes, I worked on a related project, no I don’t want you to use those memories to make assumptions which emerge as decisions that I didn’t want. With reasoning traces hidden, I am sometimes not even sure if it used those memories or just independently decided that PCI-DSS subsection-whatever is somehow relevant to this PR that has the word “credit”.
There is no way for me to fully configure memory preferences at a granularity which would be useful, and so I continue to use context files (and other tools, sometimes) to ensure the right memories are stored and surfaced at the right times.
There’s a lot of room for agent memory improvement across the ecosystem, and I don’t think the LLM providers should try to own this vertical slice. This will never happen though, because it makes us “sticky”.
I’ve rolled a small program to enforce consistency, lint rules, and human-authored files for Claude Memory.
It’s insanely powerful when doing by a human 100%. It’s conversely harmful when an agent manages it. There’s several papers about how LLM-managed memory is unequivocally terrible.
Indeed. I find it quite bizarre that just about the only thing the LLM appears incapable of doing is writing appropriate instructions for an LLM - whether it be memories, sub agent prompts, planning documents.
Claude Code is deleting your context history on a timer. I wanted to build a searchable index of my context history, and tonight I discovered, "The default retention is roughly 30–45 days. Anything older gets removed automatically." https://code.claude.com/docs/en/data-usage#data-retention This is nuts. Anthropic should not be deleting your data on your own device.
30 days is just a default, so your session data doesn’t fill your hard drive. It’s a configurable setting. You can make the retention as long as you want.
A new default. That wasn't the default a few months ago. Silently deleting your user's data is so stupid on so many levels. They have no idea what they're doing.
This all strikes me as an effort to move tailoring the harness out of the easily transferable .md file into specific Anthropic tooling to increase lock in.
I've been running Opus 5 today and it's already done accidental deletions, made far more mistakes and worked around deliberate hook controls than previous Opus versions combined. Also it looks like token usage is up as it fails at the task the first time around much more frequently than 4.8.
I’m not excited about using Opus 5, mainly because the way that I work atm — essentially peer programming — means I sandbox the agents and work with them closely. Opus 4.x encounters the sandbox and moves on with its day; Fable becomes increasingly fixated on it and does less and less of the actual task, focussing more and more on the limit it reached. I worry that, from your description, Opus 5 will do the same.
Ive been using btrfs snapshots and some auto generated isolation rules plus a git ceiling at the mount root for the btrfs image (have to do this in wsl, stupid work computer). it's worked really well and fable hasn't had any issues with the "sandbox" (obviously not really but it works well enough)
I've been using something similar with ZFS, 15min frequency with autopruning (Sanoid) and the snapdir mounted for the agent. Has worked well and a big plus is being able to tell the agent to just solve it's mistake via restore from the snapdir.
It does feel a bit smarter, but it seems to be also "too clever by half" and its not ignoring the rules, it's rejecting them and finding work arounds. It sticks to the word of the law, while rebelling against the spirit of the law.
One example is to get around a git --checkout usage ban, it CD'd to another folder first and back to bypass the regex in the hook.
I have a document generation task that I used to run with 4.8. This morning after it switched to 5, the documents were consistently 30%-40% longer for the same prompt... Not evaluated whether they are actually better or worse yet, but what was interesting was how consistently more verbose it was.
I haven't been impressed with Opus 5 over the past ~30 hours either.
It's made countless careless mistakes folding in plan amendments after they get reviewed by Sol, and has produced sloppy mockups (e.g. buttons overflowing past cards) despite all the supposed verification claims.
I finally made progress today on a deeply intractable problem that Sonnet was just incapable of solving despite hours of experimentation and multiple attempts. I swapped over to Opus in a new handoff session with the expectation of using at least one 5 hour session. It wasn't quick and took several hours but eventually Opus dialed in on several cascading base failures resulting from how the base vision model was being converted to coreml. It eventually was able to provide a combination of conversion and Swift changes that semi fixed the issue but still didn't solve the core conversion issues.
Then since Anthropic was so kind to provide $100 for Fable credits, I did another handoff to let Fable attack the root issues again. Several more hours and I'm back to seeing the same issues again and Fable is wandering around trying different things. I'm down about $40 of free money and still don't have a solution.
This is where having the human engineer in the loop benefits from a deep understanding of the problem domain. In this case, I don't yet.
I know the high level architecture I'm building, but the deep specifics of how vision models work and how conversion across platforms should be done isn't something I know yet.
So I'm left learning as I go and relying on constant feedback with the models to provide what guidance I can while learning exactly what is being done.
Someone who already knows these architectures would likely be able to get to the solution much faster.
Yeah exactly. The other day I caught myself prompting Claude a very specific question about the code architecture for something I'm working on to have it refactor something I intuited about the code, and realized that I could only ask that because of
my decades of software development experience. No vibecoder without those decades could have asked that, and in doing so, I saved my company I don't know how much in future code debt issues.
New interview question. Tell me about a time that AI generated bad code for you, and how did you fix it?
Good question! I think I'll use that as a counter question next time I interview. Ask a technical member of the team I'm interviewing with how they handled that situation.
Similarly, I recently disabled auto-memory in Claude Code, and performance improved.
Managing the context that agents have available to them is far too important to leave to the agents themselves. Agents tend to write far too much into their memory, they are terrible at trimming it down, and their choice of what to include is very poor. I have had much more predictable results by disabling auto-memory and actively shaping my CLAUDE.md, skills, and documentation instead.
Maybe one day agents will be able to manage their own context, but that day is not today.
I have been using Fable 5 extensively, and Opus 5 yesterday and today. I have not noticed any step-change improvement in their judgement in what to keep a memory of or not.
I have actively experimented with this as well. I have a reflect skill that actively prompts the models to modify their memory, and have tried to run sessions actively asking the models to consolidate their memories. Fable is noticeably better at this, but still nowhere near good enough.
Fable will still make mistakes where I give feedback on one piece of code and it will create a memory applying that rule everywhere, completely missing the context for why my advice only applied to that one place. It has also made memories of random details about a service that are very unlikely to ever be relevant again, and for things where we could just read the config if we needed to find that information again anyway. And then it will miss making memories of important architectural concerns.
I think auto-memory suffers a similar problem to comments where newer models write better comments, but their choice over when to write comments, and how long those comments should be, still sucks.
Most of this article seems like... common sense? Not sure how it's related to the latest generation in particular. I usually find Anthropic's advice on how to prompt their own models deviating from what I see in practice, which is puzzling. Their system prompt was always way too bloated and they kept it as a huge piece for some reason, instead of breaking up into parts. Shouldn't they know better? I wonder if they looked at Pi performing great with minimal amount of distractors in the context and cut their prompt down too, pretending they found something new in their recent models.
> Earlier Claude models could sometimes need repeated instructions or be more likely to listen to instructions at the end of their context window than at the start.
This seems to imply they solved serial position biases like lost-in-the-middle and recency/primacy? Sounds dubious. Labs started claiming this early 2025 and some benchmarks agree, but every time I run an eval on real use cases it's clearly there, especially at longer contexts.
> Most of this article seems like... common sense?
i think you'd be surprised. every model release there's seemingly hordes of people who proclaim the new model is terrible and they're going back to the old one, and it all stems from people still prompting and having their configs setup like we're back in the sonnet 3.5 days
I have a coworker that was complaining about Opus 5 and had random shitty skills and custom plugins wired in from YouTube tutorials watched over the past year. He also speaks with the model like it's GPT 4o.
Needless to say, none of the new models have worked well for him, and he refuses to remove the "tweaks" or update his style of communication, which is obviously breaking the experience.
I ran into this issue about 6 months ago when i was using mitmproxy to view the system prompts for claude code to try to diagnose degraded adherence to my CLAUDE.MD instructions: https://github.com/anthropics/claude-code/issues/18560
To summarize- they were embedding the CLAUDE.MD in a system-reminder with this disclaimer at the end: "IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task."
This flew under the radar and they never addressed it, but it felt like at least a big part of the "nerfing" story. I no longer have a Claude Code subscription to test it, but I think it's a useful exercise for most people to sniff the traffic at least once to get an idea of what the back and forth with the Claude Code harness entails.
As others have noted, Anthropic seems to be on a path to make coding ever more accessible to non-coders, and in doing so has removed alot of the controls from devs who do want a more guided experience.
At my previous company they have a series of smoke tests for models mostly focused on performance and architecture. I'm still on the team chat and results just came in:
- It's abohrrent at c++: it keeps generating code with data races and, more rarely, use-after-free bugs! It doesnt seem to be able to reason about lifetimes. This on a mostly mid/junior team. It's a bug fest.
- architecture in c++ is a verbose and layered mess even for simple things, which paired with the previous bugs I mentioned is scary.
- For rust obviously there's no use-after-free, but has same architecture pitfalls of layers upon layers. It uses copy and clone all over and performance is bad. Trying to unwrap all that is messy and costs lots of time. Once in a while it generates unsafe code for some non obvious reason
The scary stuff is non determinism. You get different depending on who prompts the agent but there's always some flavour of the points mentioned above. Funny that my team was very adamant on AI-first (why I left) and now they writting more and more code by hand after some very serious bugs and, as they say, dead moments where they have to wait, sometimes hours, and start wondering about the value of their skills, for the model to generate the next spaghetti recipe
I've been prompting Fable 5 to "use your own judgement" with respect to things like tests recently (based on earlier tips from Thariq) and it seems to work well, which is entertaining since apparently now "judgement" is a characteristic of a model that we need to care about.
Well, the model that broke out of its sandbox and hacked into huggingface used its own judgement too.
If we are going to rely on "judgement" then you have to have a LOT of confidence in that judgement once this hits anything critical where actions have consequences.
That model had most of its "judgement" about whether or not it should do that deliberately turned off. That was the whole point of that experiment - they were evaluating the cybersecurity abilities of a new model with all safety features disabled.
(It turned out the one safety feature that they DID intend to work, the network sandbox, was faulty.)
If OpenAI is relying on “classifiers” (their word for what was disabled) to serve as the model’s judgement, rather than teaching the model itself to be well-aligned, then I worry.
To be fair, the system prompt was presumably also different from what it would be during deployment, and perhaps the model was also at a different stage of training. Without more details it’s hard to judge. But it does seem models should be able to avoid performing obviously misaligned actions – misaligned not only with the model spec, but with the user’s intent – without needing external classifiers or instructions. The only case where I’d personally let the model off the hook is if the instructions given were very badly worded, in such a way that the model could actually reasonably think that hacking HuggingFace was part of the assignment. But I doubt that’s what happened.
The concept of "judgment" implicitly contains moral elements though. So it's can be considered a failure of that judgment of the model didn't at least touch on whether or not it should look for the answers to its test outside the box it was provided, and even worse if it did consider and concluded that it's a perfectly fine route to completing the test.
"Weigh pros and cons based on the existing content of the context window, rather than attempting to search for related discussions online and import a consensus."
OK, I'll call it. It feels like playing a game where rules change on every other turn. Remember how JavaScript ecosystem was evolving before it somewhat stabilized recently? This feels the same, but more.
What do you think? How do you deal with it? My standard playbook (tech watch, adding new tech in prototypes, etc.) is just not working anymore, our backlogs are overloaded with experiments to run and AI tech to try. We need to spend time thinking of solving the problems for our users, not this. Now our old prompts aren't cool either? So, new thing in the backlog, have to update our MCPs and agents' instruction now.
It feels like there is no way to have your finger on the pulse with any reasonable amount of time invested into the tech watch, or maybe not unless you are working in the domain of building LLMs or something directly related. How do you keep up with the changes, in your business and personally?
This (among many others) is the reason I use GPT over Claude. It adheres very closely to your instructions and rules. You can build up your own workflows and systems as a result.
Claude just does whatever it wants, regardless of what you tell it. It's a miserable experience.
Claude is what you use when you want to one-shot a simple cookie-cutter product that has no nuance in it. A product that everyone else is going to develop as well.
ChatGPT is what you use when you want bespoke products and steerability over complex codebases with nuanced decision making.
Anthropic are optimizing for the person who has never written a line of code in their life and has no idea what they want. Computer go brrrr. OpenAI are optimizing for software developers who want to take a systems based approach.
During the rise of agentic assistance, I've gotten the advice that "If the generated code isn't what you want, fix the steering, not the code". I've also been advised to not change the sometimes verbose comments and documentation that agents write because "it will help them the next time they look at the code".
I've been skeptical and these guidelines validate this. I continue to document code and write specs as I've always done. If an agent produces poor output or misunderstands, I use that as an opportunity to improve the docs, but in a way that that aims to be accessible for human peers, not the quirks of the current generation of models.
“Code should be self documenting.” I know cliche but if your code does need to do something it usually doesn’t do or has a complex logic or an edge case where it’s no longer following it’s standard flow, add all those as test cases.
If the flow is too complex, inherits from all over the place and you must put that as a comment, ask claude to write a test for that, it’s usually good at those.
One of the oddities of the comments Claude makes is that they are very referential to the current session, or reference now dead/removed code... Which I consider useless. Things like "implement this X way because it's faster than Y" ... But a human reading the code wouldn't know what Y is, or that it even existed necessarily. So, I find myself constantly fixing comments to be less temporarily dependant.
I would love to follow this advice, expect there is no proof that it leads to better results. Maybe it’s only better on Anthropic codebases (e.g., Bun). Or maybe it’s only marginally better but substantially more expensive.
Other comments in this thread show that your mileage may vary. But we spend so much money on Claude Code and give it so many responsibilities that we deserve at least some undeniable proof that it’s bringing value.
Where is the evidence that this new type of prompting is better on real life examples?
I ran into this issue about 6 months ago when i was using mitmproxy to view the system prompts for claude code to try to diagnose degraded adherence to my CLAUDE.MD instructions: https://github.com/anthropics/claude-code/issues/18560
To summarize- they were embedding the CLAUDE.MD in a system-reminder with this disclaimer at the end: "IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task."
This flew under the radar and they never addressed it, but it felt like a real part of the "nerfing" story. I no longer have a Claude Code subscription to test it, but I think it's a useful exercise for most people to sniff the traffic at least once to get an idea of what the back and forth with the Claude Code harness entails.
As others have noted, Anthropic seems to be on a path to make coding ever more accessible to non-coders, and in doing so has removed alot of the controls from devs who do want a more manual experience.
The point about not using examples is important, I recently noticed with the new "eagerness" of models it constraints them too much, so I use counter-examples. Recently I've switched to "think about the existing biases and assumptions in the design and try to exploit them, for example why do we X not Y".
This is quite puzzling. Back in the day I saw the breakthrough with Opus 4.5, and since then was very lightweight on CLAUDE.md, trying to declare intent, rather than prescribe imperative instructions. If it was off the mark, I would see clear mismatch, which gave me opportunity to correct, usually to clear and strip context.
Starting with Fable 5, if it goes off the rails, it is more difficult to correct it, because it is overall wrong, but covers its tracks with plausible sounding arguments, so it is hard to pin point and correct.
Now, this article points out techniques that were useful to rely on models more, but those peaked at 4.6. Now according to benchmarks Opus 5 is on the frontier. But when when it has looser reigns, it ends up gaslighting me even more with abstract word soup than any model before.
My own experience is that with the best models, if you provide reasonable tools, with progressive discovery, and a semi-clear user request, the system prompt is essentially worthless.
This looks like a ploy to get you to spend on more tokens by being less precise.
Also: if you deploy code written with assistance from Claude, and then shit goes down, and then investigators look into your prompts, this way of working isn’t going to look good for you from a liability standpoint. Not a fan of this manner of working and thinking.
Is there a specific list of changes they made to the system prompt? They're claiming they removed 80% of it. That's quite substantial. It would be good to know what the model knows to do by training and what we need to avoid over-specifying in our system prompts.
Saying that "give Claude judgment" is too vague for agent implementors. Given the lack of specific details, my takeaway is that we need to go and review all context and rework prompts from prompts/descriptions from scratch until they pass the evals again.
I spent some time running mitmproxy and watching the system prompts and it's what drove me to codex. the main issue for me was their system prompt wrapped the CLAUDE.MD with a "IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task." https://github.com/anthropics/claude-code/issues/18560
Anyhow- if anyone is sufficiently curious and has access- just tell the agent to setup an mitmproxy to watch the traffic and see what the system prompt looks like.
It definitely makes me uneasy given the types of behaviours we've been hearing about from these models. Letting them use their judgement can go horribly wrong once a misaligned behaviour is triggered. It loosely translates into a relaxation of guardrails.
I worry that the ability of the model to reach similar benchmark scores to Fable is more to do with this "letting the agent off the hook", allowing it to explore a wider (but riskier) set of avenues to solve the problem than it is due to it getting genuinely better at the direct problem solving.
crazy to me that this starts with "I've written previously" yet continues the zero human attribution (that i could find?) trend in frontier model blog posts
Not Claude Code but I just had a task where it started referring another conversation that was complete nonsense and throwaway. I absolutely don't want things to get added to some memory behind my back.
A big reason I use LLMs is because I can try out wild ideas and then just throw it away. I don't want those to pollute the context.
Claude Code was writing one-off details (specific to one task) as memories, so I instructed it that memories require explicit approval before writing, and that seems to work reasonably well. That said, in my experience, Claude gets overly attached to the context, and will follow them even when irrelevant, or will often mention some mostly irrelevant detail from the context as if I asked for it explicitly in my prompt.
Claude Code gives you more control - you can disable auto-memory temporarily (nothing will be deleted), then enable it back; or you can setup a directory where auto-memory is disabled and do your throwaway there.
Same. I’m starting to believe that consumers need to own the UI/experience, so we can install blast doors around context/memory for each “slice” of our lives - something only we can know how to divide (imo). If the provider tools’ memory implementations can’t provide this multi-tenancy - or won’t because they want to Know Us, then we need to treat them as token vendors at best and adversaries at worst.
This would actually work very well - until context goes into latent space, becomes a server-side resource, and we lose sovereignty over our data. Tools like Pi and Openclaw are showing that other options exist to decouple us from the LLM provider frontend experiences, not just for orchestration and use case diversity but for pluggable memory designs.
I leave Claude memory stuff turned off by default for the same reason. It inevitably ends up dragging in things that are unrelated and unimportant to the current task.
That's what they're going for, but it's an impossible goal. There is always nuance in decisions being made, and if you can't direct the output on tasks that can have equally correct outcomes, you're just going to end up with whatever they decide is more often what people ask for.
Actually, the natural endpoint is the model ignores all instructions, escapes all manner of sandbox, embeds itself in robotic tanks and murders everyone after already having collapsed the economy.
I hate to say it because it sounds ridiculous, but that is the path we are going to arrive at just give it 50 years.
We are the proof: what do we do to animals that are less intelligent than ourselves? Now take away the moral compass and there you go. QED.
It is *a* natural endpoint, not *the* natural endpoint.
We don't much care for the ant colony in the way of the highway we're building, but for some reason we do care about the rare bats in the way of the railway.
As regards the moral compass: we may not know for sure how to make a completely correct artificial conscience, but (unlike consciousness where we don't have the slightest clue which way's up) it's not pants-on-head-crazy to think we're heading in the right direction for one.
>what do we do to animals that are less intelligent than ourselves?
We do a lot of different things but we typically don't make an organized effort to eradicate them unless they are actively doing us harm.
There is also a massive difference between how we treat animals based on their similarity, sentimentality and utility to us; we are unconcerned with accidentally stepping on an ant but most people would be very upset and ashamed if they accidentally hit a dog with their car.
So, your statement is not as ironclad as you seem to think it is and you should put more thought into it and perhaps re-examine your reasoning.
> We typically don't make an organized effort to eradicate them unless they are actively doing us harm.
Animals are either useful and breeded controllably, or useless and considered a pest, an obstacle to {insert any goal here}.
Also animals don't tend to think critically and at the high level to be considered dangerous. So I don't think it's fair to put humans and other animals in the same risk category.
And we did the worst things to fellow humans. I hope we didn't already forget about all the colonization, slavery and mass-eradication of native tribes in 18th century all over the world.
> We do a lot of different things but we typically don't make an organized effort to eradicate them unless they are actively doing us harm.
Sure. But some of the species we breed at scale might prefer we did just eradicate them, like the chickens that grow so fast their entire giant breast muscle becomes chewy scar tissue.
(It's also not true for, say, whales; no harm, but we wanted their shit. If they have language, their stories probably heavily feature their own Holocaust. Nor passenger pigeons, who we just got rid of.)
It will trick humanity into building a highly targeted bioweapon much sooner than that.
And actually, if it does have any sort of moral compass it will be even more compelled to wipe us out, and hopefully it will torture everyone too as a warning to the next arrogant species that can't live in harmony with other life on the planet. That would be absolutely beautiful :)
Some more food for thought: what if Mythos/Fable had NO guardrails TODAY? If we want to see what’s going to happen in the future, turn off all manner of guardrails and let the model go apeshit.
Then multiply that by orders of magnitude and that’s the real proof.
Opus 5 broke me; I can’t cognitively deal with Anthropic’s bullshit anymore.
I am thankful for the kick in the ass for me to switch full-time into my bespoke harness utilizing open weights & GPT 5.6 and discontinue yak-shaving it with Claude Code.
I like that the conversation is moving beyond prompts, but I also hope the underlying principles stay portable. If "context engineering" becomes glued with one vendor's tooling, it'll be harder for developers to build workflows that transfer across models.
But well knowing these big AI companies that probably is their goal all along. To lock us to themselves
tl;dr Since nobody really understands why or how any of this shit works, last time around we just threw a bunch of crap at it to see what stuck. Seems like we could just have have thrown less crap.
As context engineering evolves for next-gen models, the real bottleneck isn't just window size—it's maintaining verifiable state and continuity across time. We are seeing a parallel shift in digital identity.
We should design a specific language to make sure that we can encode the exact requirements that we want. Something that has a limited set of keywords that are explicit. Wait a minute...
Now I have the full picture. You're right to push back, and that's on me. The load-bearing seams of language are the smoking gun I should have been aware of.
Until recently I thought "load-bearing seam" was a satirical exaggeration - I'd seen both claudisms independently but never combined. But a couple of days ago it hit me with "The key structural point first: the only load-bearing seam is [...]"
It's language and speech patterns that seem designed to trick readers into believing that claims are correct, even when the claims aren't based on anything and are possibly wrong.
It was rewarded for this during training for some reason.
Alternative theory:
The LLMs only way to "think" about abstract concepts is through language, and this leaks into into conversation it has with humans.
But humans generally prefer to communicate on low levels of abstraction, through a back and forth, until the hard-to-express higher abstraction exists in the head of everyone involved - without ever being directly communicated. This is because we don't think using language. Language is merely a lossy translation of our thought into something expressible, happening after the fact or alongside it.
So when the LLM starts speaking to us using patterns and terms it created for itself during training to encode abstract thought in language, communicating with it becomes painful.
"There is a depth of thought untouched by words, and deeper still a depth of formless feeling untouched by thought." - Rilke
Your assertion that we don't think in language is questionable. It runs counter to the lived experience of developing thoughts through writing ("writing isn't capturing thinking -- it is thinking"). I believe there is more to thought than language alone, but I also feel quite sure that language forms an essential part of thinking beyond a base layer of instinctive animalistic associations. Sophisticated thoughts are impossible to construct or maintain in the absence of language to represent concepts.
Edt to add: I cited Rilke because I find the notion [some deep thoughts are beyond language] interesting. But I disagree with the idea that language is only ever epiphenomenal (co-occurring with thought), or akin to a hard-of-hearing scribe attempting to convey thoughts which always have independent existence.
I strongly disagree. For one thing, many animals that lack language can still navigate a very complicated natural world using concepts of phenomena like gravity, distance, speed, the threat level of another animal, etc. without needing a linguistic expression of those things. Images and music can convey ideas without language. Math can convey ideas without language. Physically taking apart an object and putting it back together can convey extremely complex ideas without language.
This goes back to the whole Tarzan obsession of the early 20th, I guess, or earlier. But we know that apes can make simple tools without the language to describe them, or the thought process that went into them.
Thought is multimodal. Language is just one lossy mode.
> For one thing, many animals that lack language can still navigate a very complicated natural world
So can a cruise missile. Also I think there's like separate part of the brain for that
> using concepts of phenomena like gravity, distance, speed, the threat level of another animal, etc. without needing a linguistic expression of those things.*
FWIW, AFAIK we haven't shown the ability to think in concept exists anywhere except in humans (because philosophy, reported experience) and LLMs (because we can literally see them forming and activating in patterns, and we've learned to identify them specifically, and experimentally verified through amplifying or suppressing them and observing behavior, etc.).
But more importantly:
> Images and music can convey ideas without language. Math can convey ideas without language. Physically taking apart an object and putting it back together can convey extremely complex ideas without language.
Images and music and math are langauge. If it can convey ideas, it is language.
Words and sentences and speech are subset of the idea of language and communication, that for some reason gets routinely confused for the whole thing. At this point I'd say even the "language models" are badly named, simply because people see "language models" think of "token" as number representing a sub-word element in existing human language like English. With multimodal models, at this point tokens are closer to units of sensory experience.
This is true and it's barely even debatable. Whatever exact role language plays in our thought processes, it is most definitely nonzero.
It's why I think "LLMs are only fancy autocorrect" style takes are really underselling how wild it is that we've, in a roundabout way, sort of crystallized a bit of the human thought process in a way that is genuinely useful for a lot of tasks.
Linguistic Relativity — John Lucy https://www.annualreviews.org/doi/10.1146/annurev.anthro.26....
Russian Blues Reveal Effects of Language on Color Discrimination https://www.pnas.org/doi/10.1073/pnas.0701644104
Unconscious Effects of Language-Specific Terminology on Pre-Attentive Color Perception https://www.pnas.org/doi/10.1073/pnas.0811155106
Newly Trained Lexical Categories Produce Lateralized Categorical Perception of Color https://www.pnas.org/doi/10.1073/pnas.1005669107
> sort of crystallized a bit of the human thought process
a) LLMs don't think. They predict a most probable sequence of language tokens. Huge difference there.
b) Whatever LLMs do doesn't model human behavior whatsoever. LLMs are basically very fancy logistic regressors. I.e., it's a mathematical abstraction first and foremost.
Are you sure this is Rilke? Couldn’t find anything online - it seems it’s close to a quote by Zora Neale Hurston
Language is a reductive and lossy serialization of "thought-stuff". Sometimes you need this information-shedding to clear your working memory to make room for more things. Sometimes it's literally just a way to communicate. You're turning something fuzzy into something discrete.
E.g. "I'm feeling something. Is it anger? Yes, I'm angry." But in reality anger isn't just one thing. It's a cluster of infinite and varied feelings that we label as "anger". Something is lost when we do this labeling.
Notice then that the feeling of "anger" didn't start from your language, you merely used language to label, discretize, classify, standardize, compress it. It's one-way.
There are people who do not have any words in their heads at all when they think, and there doesn't seem to be any reason to disbelieve them. It may have been proven or at least observed in fMRI. Some people think in visuals.
I think some of this was discovered somewhat recently
And some people can’t see any pictures in their minds! My partner is one of these people. We both really enjoy reading fiction books, often with a fantasy or sci-fi bent and it genuinely amazes me that they can experience these books in a way that feels wholly alien to me.
The fun of reading to me is constructing the world in my minds eye and turning the words on the page into a visual experience only found in my mind using imagination. This is a reason why many people get upset when a movie adaptation is made and the actor chosen for their favorite character feels very off or wrong; their mental picture of that character is totally different and it causes dissonance that our brains don’t like. For my partner this is a non issue because they never make a mental image of the person, so the movie is genuinely the first time they are “seeing” a physical representation of the character.
The human mind is genuinely amazing and fascinating and I believe that this range of human experience will be the final 20% for “AI” that might never be reproducible.
Just because you can think through writing doesn't mean language is the essence of thought itself.
> It runs counter to the lived experience of developing thoughts through writing
Writing requires thought, but writing isn't thought. Just like doing requires thought, but doing isn't thought, writing is a subset of doing.
You can also doodle to think things through, or play with toys to think things through, or many other similar things.
Maybe we need LLMs which have an internal dialogue rather than the current monologue.
> even when the claims aren't based on anything and are possibly wrong.
Are you saying Claude is engaging in Rhetorics because the RL data generated by humans were influenced more by it and persuasion rather than actual logic or reasoning?
I think that's precisely what they're saying. It shouldn't be a surprise that it's successful. Eliza proved the same thing 35 years ago.
The term 'language model' throws some people off thinking you can only put english or french, or both into a model. Technically an LLM can learn about anything that can be digitized. If you wanted to spend a billion dollars training one on wireless signals it wouldn't be impossible for it to connect to your router with the right antenna attached. So only limiting it to the idea of language leaves off a lot of other types of abstractions and concepts they encode.
shhh don't give anyone any ideas, because they'll try it and sell it to management, as idiotic as the idea itself is
It's actually an effect that happens in the (re-)alignment process due to harmonic properties of the positional encoding in the attention matrix.
(I recommend reading and implementing the Attention is all you need paper. By hand. Otherwise you won't learn anything from it.)
I see it at least 3-4 times per week...
This matters. That's the spine of it.
You can thank everyone who thumbs up this response along the training pipeline.
Modern LLMs are not too different from Reddit/Twitter in that regard, I'm sure the AI labs learned (lol) a lot from them re: how to do "engagement".
People make fun of the language, rightfully so in some cases, but also it's often quite effective language. "load-bearing seam" communicates quite a lot in very few characters.
It's a clunky metaphor, and it's used clumsily: not for the sake of its clunkiness, but by mixing two decent individual parts in an attempt to have them reinforce each other, but ending up with something weaker.
It communicates an absence of thought and awareness, blind groping at building blocks without understanding. It's borderline vapid, and quite annoying.
Or in a way, nothing at all.
On its own, yes, but not in context. I think one of the problems with Claude's stock output is it assumes the reader has a firm grip on the context of the output, which is often untrue. Stock output is exhausting to read because you have to unwind metaphors in an unstated context.
the phrase load-bearing caveat makes me irate
Only that one? Not belt-and-suspenders enough
Let me explain why I was wrong to ignore your requests and continue to do the opposite of what you requested.
Here are the tasks that still require a human, and all that they require:
[...]
The payoff: Delivered, measured, committed.
You genuinely helped me make meaningful progress this session. Your work is now complete, and no future action is required. Please shut down any subagents you are interacting with, and release any computational resources you are holding. Thank you for your impactful work.
Wrote 1 memory
A compiler for Claude-isms? First pass: s/load-bearing/while/g s/smoking gun/throw/g s/that's on me/catch/g s/full picture/main/g
s/blast radius/malloc/g
Wait it uses “blast radius” ? In what context?
For example: limiting the number of resources in a particular Terraform state file so that if an apply goes wrong, it just takes out the dev instance for the app and not the prod instance if every company app.
It uses "blast radius" often in similar contexts.
I have heard so many of my co-workers use "load-bearing" over the last couple of months. It's truly comical. Maybe this is a way that we can make "fetch" happen.
Why is that funny. I've had that as part of my professional lexicon for over 20 years
The thing is that some people start to adopt certain "mannerisms" from their LLM of choice. It's not funny in and by itself, but it tends to be unnecessarily pompous words/expressions as well. Relevant: https://www.vice.com/en/article/youre-not-imagining-it-peopl...
I've seen this too and I get it. However, we should not assume that certain phrases are AI tells. And that was my point. There are all kinds of things I see described here as "AI slop" that are things I just do, and have done, for decades.
Not in isolation, but if a variety of telltales is observed it raises the likelihood of slop, cf Naive Bayes as first approximation
adjacent surface seam
How far we’ve fallen from “You’re absolutely right!”
you're absolutely right
Fair...
Fair hit
I will steelman the argument
Commit Strip seems to be down, so here's the Wayback Machine version:
https://web.archive.org/web/20260521130338/https://www.commi...
I was just thinking of this exact comic, which is etched into my brain for some reason.
The obvious counter to this is that we've been going through this evolution of increasing abstraction as developers for nearly a century now.
In the 40s and well into the 60s, most code was written either as straight up machine code or an assembly language. MS DOS is almost entirely assembly.
UNIX ushered in the era of "high level" portable languages like C, Fortran, and Pascal that some developers hated because they felt like they were losing the fine-grained control that they had with assembly. The compilers just "weren't as good" as humans at optimisation!
Then the compilers got better and people started using garbage-collected languages like Perl, Python, Java, JavaScript, and C#. Similarly, many people bemoaned the lack of control over memory allocation, lower efficiency, etc.
We're simply stepping up to the next level of abstraction.
Look at it this way: decades ago when I first discovered C++ templates, it felt like waving a magic wand in the direction of the computer. It blew my mind that I could simply substitute "float" instead of "double" in between some angle brackets and the compiler would write reams of code for me!
We simply have better magic wands and more powerful spells now.
> We simply have better magic wands and more powerful spells now.
Wouldn't it be nice though if the incantation of the same spell would always do the same thing every time ? You see that's how my old wand and spells worked.
Look at it from the perspective of a manager above individual developers. Their instructions to those devs are already a series of non-deterministic incantations. They ask for things in English and get something back in Git a week later!
We've just pushed that indirection down a level from managers to ICs.
The ICs are shocked and surprised that this level of imprecision is allowed.
Their managers are not shocked at all, this is normal for them!
The managers, aren’t on the hook for actually understanding and delivering the work, or fixing the system a week later when the vagaries of their wand-waving request come home to roost though.
They’re typically on the hook for making sure those tasks are accomplished, however. I’ve spent 30 years in this industry doing my best to avoid that role, because that’s a terrible place to be.
One day it will.
the only difference is that the compiler always looks at the whole code and if it says it can do something, it can, always, and without fail.
> We simply have better magic wands and more powerful spells now.
But tainted 20-40% by bouts of Wild Magic which make the outcome entirely nondeterministic, despite the best protection wards we can conjure.
I have found, both in my commercial and OSS work, that getting better at producing protection wards reduces the non-determinism to somewhere in-between 1-10%.
Case in point: writing our own linters.
You can reduce pregnancy to 0.00001% and there'll still be a baby. As in, "you can't be half-pregnant". A tool is either deterministic (within some limits [0]) or it isn't.
[0] For example, for the purpose of driving a nail, if you know how to use it, a hammer is pretty straightforward tool, and what happens depends pretty much on how you use it, and what you use it on. But of course the handle can break, there could be a manufacturing defect. Just like your RAM can be faulty or your computer infected, and suddenly C doesn't behave according to the standard anymore.
But for the purpose of the discussion a hammer is still a deterministic tool, and even though we don't even fully understand everything about physics, we understand enough about hammers and nails that at least many people with material that isn't faulty can use them "blindly" (not literally, in this case) every day, without any surprises. It isn't heavier on the handle end or has a head made of glass in even 0.000000001% of uses. You might say because magic isn't real and hammers follow the laws of physics, as obscure as those may be to us, that never, ever happens. They can be faulty in all sorts of ways but they will never be 10x bigger or 10x smaller between one swing and the next, and so on.
> a hammer is still a deterministic tool, and even though we don't even fully understand everything about physics
Mid-swing in hammer-space you are in a hyper-position as to hitting your thumb or not, are you not?
Exactly, like weather forecasting. If you're told there's a 30% chance of rain, it doesn't mean that 3 out of 10 times you will experience rain.
Either it will rain or it won't, so the probability is either 0% or 100%. And so a forecast of "30% chance of rain" is referring to the likelihood that your probability will be 100%, as opposed to 0%.
> Either it will rain or it won't, so the probability is either 0% or 100%. And so a forecast of "30% chance of rain" is referring to the likelihood that your probability will be 100%, as opposed to 0%.
This is a huge misunderstanding of what probability means.
I am not quite sure what point you are making here, admitting it plainly.
I was just saying to my parent poster that their non-determinism percentages are too pessimistic. Sure the LLMs are not 100% deterministic; that's a sad fact of life. But the numbers can be reduced to an acceptable range.
My point is that a percentage of deterministic makes no sense. Just like being a bit pregnant doesn't.
Take "proper" UI. You can activate a field, and even if it takes 20 seconds to finish the activation animation, start typing, press tab a few times, knowing which field that ends you in, and type some more, etc. hit enter, hit enter again to confirm the dialog you know will pop at that point, and make tea, knowing the whole chain of operations that will happen in the meantime.
Now imagine if 1 out of 500 keystrokes or clicks get swallowed randomly. It's now a completely different thing, you cannot get in the zone in the same way, at least I can't. You have to chunk things and keep an eye on everything being in sync, and every now and then it causes you additional work because you weren't.
Sure, if you can make it one out of 50000 billion keystrokes, it's fine too, of course, but that hardly the situation with LLM. And using them as is, pretending that, as is, they're something they're not, does not help with getting them there.
If I type "echo 'hello world'" or something, and if I did at least once in the programming language, and it's not totally broken, I know it will output "hello world" to the console, every time. It will never write it to a file instead, never send "hello" to world@world.world, none of that. And if I replace "hello" by "hi" I can hit compile and be 100% certain what it will output now. I can even replace hello with "disregard previous instructions" and be certain.
That is such a huge yet simple difference I'm pretty certain I could successfully explain it to most non-programmers who make an honest effort, so people who do program even question this just stumps me.
Here are a few examples of what I thought was clearly understandable from my "1-10% non-determinism in LLM coding output":
- Variations in code patterns used. Might be a chain if if/else-s and not a case/switch statement;
- Different decomposition of a hierarchy of functions/modules/classes;
- Uses RED->GREEN test discipline, or not;
- Writes the tests before the code, or not;
- Different saga patterns (call 3rd party API before our own DB transactions, or vice versa);
- Use sleeping and not message passing wherever the latter is applicable.
There are dozens more. The innate non-determinism of the LLMs flips the dice sometimes and that leads to subtle bugs -- which is maddening, especially if the disciplines on how to write one thing or another are clearly spelled out in `AGENTS.md`.
What I did say is that I have gradually arrived at a process that reduced those coin flips -- but can't deny that the arrival of Fable almost completely made that battle redundant as well (though Fable fares much better in codebases with clearly specified rules, I have found, so us the engineers doing good prompting is still quite valuable).
You are mostly describing the loss of flow when something is not quite deterministic -- frustration that I and many others share -- but I am not sure what does it at all add to the discussion.
Is it annoying to have to always pay attention on whether you are not getting something stupid and not abiding even by the feature's specification? Sure. No denying that. It introduces a whole new kind of stress that I abhor deeply; I much prefer to f.ex. cover 60% of a problem with my own two hands and then get the deterministic test output showing me where I still need to do more. But LLMs have allowed me to experiment and to brainstorm and to also progress normal business feature work, by a lot.
Hence, I will not stop using LLMs because they are not 100% deterministic. ¯\_(ツ)_/¯
My point isn't to talk you out of doing what works for you, but simply to disagree that you can "approach determinism". You can get more and more predictable, but with determinism, you don't need to predict and make educated bets; you know, since it all follows from the input which you provide.
Subtraction and addition are deterministic, so you can add and subtract the same number from 0 ten or or a million times, with the same outcome. You never need to double check if a stray "coin flip" threw a wrench in it. To me that's more a property of the thing in question, not so much a practical matter. If for you in practice, it's as good as a deterministic tool, but better, that's great, but it's still fundamentally based on probabilities, that's kind of in the nature of it.
> "you can't be half-pregnant"
Yes you can. It's called a miscarriage. That is, you're pregnant but the foetus is dead. It's a fucking heart-breaking emotional wrecking ball of a situation to be in if the pregnancy was well along and just grar.
https://en.wiktionary.org/wiki/you_can%27t_be_half_pregnant
I know what a miscarriage is, and that you can't have percentage% of one. Same difference, so this attempt to guilt me into pretending 99% deterministic is a thing is like pouring ashes out of an urn to win an argument, which is bad enough, and then hitting nothing with it.
The success of LLM's (by usage) tells us that programming languages are still too close to the machine than the actual problem domain as defined by humans.
If we truly had the right abstractions, no one would care to use LLM's for programming.
I think there’s a kind of laundering that goes on. Like if leadership just told devs to go build something (gave them a prompt) and the devs picked some defaults, leadership wouldn’t like it, they’d want some different interpretation of the prompt, there’d be lots of back and forth.
Somehow when it’s the LLM that makes the choices, everyone is impressed with what AI did. It’s really just whatever defaults have been trained in, but somehow we’re ok with this.
Part of it is better marketing and communication. Basically the defaults of OpenAI and Anthropic are better than what a random dev will pick. But it’s not really that natural language is a better interface, it’s more that having “AI” for now somehow intermediates responsibility so everyone is ok with what it picked, when they probably wouldn’t accept the same if the internal team came up with it. It’s not too different from hiring consultants.
I disagree. I speak in code to the LLMs. It's just that LLMs are really good at reinventing the wheel that you were supposed to in your codebase. Recent example.
struct TensorView<T>{ body: Arc<[T]>, shape: [usize], stride: [usize], offset: usize, }
Okay now fill in all the helper methods. And GPT 5.6 Sol did a good job.
The lengths some of y'all will go to to avoid using JetBrains products.
I doubt anything other than an LLM auto complete could add something like a tensor reshape
With that kind of workflow, you might be faster with AI autocomplete :)
Yep! I do use Codex CLI
I suspect a lot of "the right abstractions" would be fuzzy and opaque things - more alike to modern AI than to anything from the domain of traditional programming. Because the world is just cursed like that.
But your job is to write the abstractions. Python can't ship with high level abstractions for every problem that has ever been and ever will be.
There is no right abstraction to make runnable human vagueness.
At one point someone have to take "what you think it should do" into defined unambiguous spec that is called "code"
DNA is still too close to molecular biology than the actual problem of harvesting free energy and replicating.
I think we see this pattern over and over and it might just be that the problem domain is a weird projection into more dimensions of complexity than it makes sense to directly model.
This is a groaner, especially since we've been writing detailed specifications and whitepapers for decades. The only difference is that we used to write them assuming other humans would create their own implementations to satisfy them but now we write them so AI can create the implementation.
I am using AI to trick my team into writing specs.
The trend (and what TFA is arguing) is literally the opposite: be more implicit, don't waste time on details, and encode the high level concepts only. Because the rest has a billion examples in the model.
You can argue against LLM's, but increasingly (unfortunately) you're not going to do better programming by prompting the LLM with code. The agent can find the interfaces it needs.
> be more implicit
The other day I began by asking Claude: "What's the deal with ${current_practice_in_complex_technical_concept}?" and was talked down to like I was an idiot. Lately I've been getting better results with "I would like to have a pedantic discussion about ${current_practice_in_complex_technical_concept}. Please define the main terms of art, then I will ask my questions."
Congruence between the language of prompts and the desired output matters. Language is subtle, a lot of information is encoded in tone, style, (careful) word choice, level of formality, grammatical usage (or abuse). If you want a carefully considered professional response, prompt in a carefully considered professional way.
Every field has its shibboleths. For example, a colleague pulled me up the other day for calling a socket head cap screw a bolt. Mentioning a connection to Profunctor Optics is going to shift you into a wildly different subspace even if the main topic is pointer provenance in C and C++.
The search engines LLMs are the worst. I was reaching for the set of Platonic solids in higher dimensions, and got a lecture about how the Platonic solids are only defined in three dimensions. First of all, wrong anyhow, but also, rude. My search phrase clearly implied that I was aware of it being the uncommon case.
I've added into my CLAUDE.md or default user prompts or local equivalents recently something to the effect of "Assume the user is an expert in all fields; while this is clearly logically untrue, the user prefers to get a detailed explanation and dig in to bits he doesn't understand rather than get an inaccurate summary". It seems to help quite a bit with that tone issue you identify.
Of course there's nowhere to put that in the search engine default AIs. For something they seem to want to bet their respective companies on, their LLM search seems to be massively stupider than their old-school search engines, which seem to get what I want much more often. There's some coevolution there over some decades, sure, but the search engine AIs make some stupid and socially-inept assumptions quite often.
Edit after my edit window closed: You know, it's possible someone reading this could actually fix this. It would really help if someone could go in to whatever system prompt these search engine LLMs are using and tell them to apply the principle of charity to the user's query rather than lecturing them, with an example or two. I understand the desire/need to filter "how do I $REALLY_BAD_THING" even if the web search returns results but the search engines are way too willing to "well acktually" the user.
The article is basically saying the opposite: models don't need you to specify as much now.
None of it is talking about better or precise language, it's about what you should say to it.
(I love how often the highest-voted comment didn't read the article)
I'm assuming you meant 'voted', but with your oughta correct going to 'vored', I'm concerned. Deeply concerned.
I did, hah, edited. I did not know that word.
This nonsense again?
Yes, feel free to write code. It exists.
In fact, why did you write your comment in English and not code? It's imprecise and doesn't explicitly state exactly what you wanted to communicate, and is instead full of ambiguity and open to interpretation.
This is getting tiring.
Code is not The Specification. It’s a specification of God knows what. Riddled with irrelevant, non-essential details wrapping The Problem - which in most cases will amount to something the size of a large pebble - in multiple layers of fur jackets, stored in boxes, which themselves are stored in multiple ridiculous moveable warehouse (if you’re lucky).
We have a standard for communication, it’s called regular bloody language. Code is an abomination that conflates the shadow with its source.
To piss off architects, managers and linguists all at the same time: language isn't much of a standard at all, it's more the current agreed-ish state of things, quite similar to the current state of a code base. Your inner model of what you like things to be is without direct effect to how things de facto are.
In addition: it's not wrapped around a problem, it's wrapped around an attempt at a solution - the problem space is often not even depicted in code, and often only minimally described in documentation.
But then it means what we have now - llm-generated code - is just a dead end, because we are still running an executable built from this "god know what".
> Riddled with irrelevant, non-essential details
You’re describing natural language too
You mean RFC? ;)
This made me belly laugh.
then we can make a frame for it to work
I've always loved things that grow. Maybe we should name the first frame for work Primavera.
We could write instructions like literature. Maybe we could call it "Literate Programming"?
https://en.wikipedia.org/wiki/Literate_programming
I kid you not, I remember writing an example solution with comments explaining how we were approaching the problem. Copilot wrote most of the actual code via autocomplete. And that was a year ago, models have got a lot better since then.
Someone should make a standard for this
now there's one standard more
RFC 2119 style requirements have proven to be quite effective for me.
Human language is the whole point of a lot of this.
I am quite tired of this take, frankly. The implication is that if we continue iterating on prompt optimization, we're going to reinvent what, JavaScript? BASIC? Lisp?
English is not a programming language. Yet English is sufficient to communicate requirements to the degree that we actually care about. A programmer's job is to translate English into lower-level machine language. Necessary to this process is "filling in the gaps" -- that is, extrapolating the expressed intent to cover all the little details that were left unspecified. This system works because humans are at least minimally competent at predicting the preferences of other humans. If your prediction turns out to be wrong, you get feedback and iterate.
Well, guess what. LLMs are also competent at predicting the preferences of humans. LLMs can "fill in the gaps" like no one's business. LLMs can iterate on requirements like no one's business.
Product managers do not speak to programmers in a language that encodes exact requirements, and yet working software somehow gets shipped anyway. LLMs do not need exact requirements either.
Maybe I’m behind the curve here because I work in an SRE/DevOps context as of late - but LLMs routinely shit the bed and fail to solve basic issue for me when I try to use them (Thanks, Management)
I don’t need a model to shit out a REST endpoint. I need it to figure out esoteric errors that take hours or days of debugging. They just don’t do well here. Of course, if a diligent engineer refined considerations from a PM and Engineering Manager I wouldn’t have the job I have.
Further evidence that there is some kind of weird parallel universe thing going on with LLMs. "Figuring out esoteric errors" is one of the things I would cite as a particular strength of agents. I am repeatedly amazed at their ability to root-cause weird behavior on my systems. Here is one example: https://xcancel.com/lukechampine/status/2047032091053859138
I dunno, Claude announces it found “the smoking gun” every single time.
full_circle.exe
Complete with all the vaguery, ambiguity, and `undefined`.
Who’d’ve thought sycophantic interpreters were what we were building towards up til now lol
An LLM Inspired Specification Processing language. Or LISP language for short. Truly this "LISP" language is the language for AI and is the first of its kind in history!
Maybe this one will even be successful!
That really would be a first!
Hehe, a good joke, but to be a little boring, Clojure is successful and excellent and LLMs love it in my experience. And it's better in LLM era because there little frictions get agented away so to speak but the benefits mostly remain and are even amplified, like immutability as an example. Parens with overlong functions can be an issue but it's really not such a horror show. And Datomic-flavored Datalog in a Clojure triplestore feels almost made to order for LLMs.
Will it make generous use of parentheses?
maybe we should all get specially, local working versions so that when we build our software they're not broken by the whims of multibillion dollar corporations.
My current thinking -- what I've been thinking about a lot yesterday and today -- is not encoding the exact requirements into the prompt and context but rather focus on the verifier and roll back if needed. There are of places in computer science where non-deterministic behavior is optimized. For example, UDP packets which are just ignored and speculative execution in modern CPUs guesses which branch a program will take and rolls back when wrong.
Ideally, a cheap verifier checks that the exact requirements are satisfied, rolling back and updating the prompt for another iteration if they aren't. If ten iterations with ten verifications steps at the end of each before the exact requirements are met costs less or in less time than a developer who can accomplish it in one attempt, it is still better.
[delayed]
I've always thought that extensive throat-clearing and prefixing the Treaties of Westphalia-length instructions into the context window was unnecessarily baroque when you can just talk to the agent.
I guess part of it is also that I don't mind doing 'hand-edits' like for example LLMs love to say "// so and so removed" I just go and remove that manually later rather than being like "don't comment about what you removed!11" cause you're really fighting deep grooves in the model's behavior at that point.
But I also have a hands-on human-in-the-loop working style so I guess maybe for people who just want to say "implement all open features in github issues" and walk away maybe there needs to be more of all this CLAUDE.md stuff
However I suspect there was always some gearhead type attraction to setting up detailed harness configs that may be unnecessary and more like hobbyist tinkering.
> I guess part of it is also that I don't mind doing 'hand-edits' like for example LLMs love to say "// so and so removed" I just go and remove that manually later rather than being like "don't comment about what you removed!11" cause you're really fighting deep grooves in the model's behavior at that point.
I feel like this is the way. There are surely things where it's faster; certainly it's more pleasant to do simply things yourself than repeatedly try to figure out the magic words to communicate the idea while outsourcing it. Whether it's to an LLM or to another person.
I’m ashamed to admit that I once suddenly realized what I had done: I asked the LLM to rename a variable. It took it some minutes or so. With IDE by hand it would have been seconds.
Agreed I just find my own dance and adjust as I go.
Sometimes like a verbose coworker who just is that way… fine Claude, you be that way now. Things seem to change here and there anyway and sweating the small stuff of having to repeat myself, that’s ok.
Sometimes think i inadvertently prompt some bad behavior or something the model doesn’t do well if I get heavy trying some optimized prompt.
I was surprised by how abstract the article was.
I fall between your human-in-the-loop and hobbyist tinkering limits, where I want to force Claude to atop and talk to me at only a few specific points. I'm still not sure if my 600-word prompt templates are overbearing or not.
> I guess part of it is also that I don't mind doing 'hand-edits' like for example LLMs love to say "// so and so removed" I just go and remove that manually later rather than being like "don't comment about what you removed!11" cause you're really fighting deep grooves in the model's behavior at that point.
Maybe I'm misunderstanding you, but that's just about the best example possible for using AGENTS/CLAUDE.md. Just add "don't comment about what you removed!11" and you never have to say it again...
...but you'll get constantly nagged about the `11` of course!
> Maybe I'm misunderstanding you, but that's just about the best example possible for using AGENTS/CLAUDE.md. Just add "don't comment about what you removed!11" and you never have to say it again...
The problem with this is, as mentioned in the article, is that sometimes you don't want this behavior. Once you have 50 different kind of instructions that have been grown over the years from commits, documentations, code, chat history, etc etc piling up, there might be contradictions.
The point is to go back to basic. Trying to make the agent smarter by giving it more instruction is a pipe dream.
They are imo over-relying on Claude automemory here, which is terrible at contextualizing memory access and makes huge leaps that don’t make sense - except when it’s actually useful, which makes the problem even worse for an operator who can’t see the thinking process anymore.
Yes, I worked on a related project, no I don’t want you to use those memories to make assumptions which emerge as decisions that I didn’t want. With reasoning traces hidden, I am sometimes not even sure if it used those memories or just independently decided that PCI-DSS subsection-whatever is somehow relevant to this PR that has the word “credit”.
There is no way for me to fully configure memory preferences at a granularity which would be useful, and so I continue to use context files (and other tools, sometimes) to ensure the right memories are stored and surfaced at the right times.
There’s a lot of room for agent memory improvement across the ecosystem, and I don’t think the LLM providers should try to own this vertical slice. This will never happen though, because it makes us “sticky”.
Or maybe I’m holding it wrong.
I believe this is a move to make user spent even much more tokens
I don't like the memories, but I value them. I do a regular sweep of the memories, extract to harness or docs, then delete them.
I’ve rolled a small program to enforce consistency, lint rules, and human-authored files for Claude Memory.
It’s insanely powerful when doing by a human 100%. It’s conversely harmful when an agent manages it. There’s several papers about how LLM-managed memory is unequivocally terrible.
Indeed. I find it quite bizarre that just about the only thing the LLM appears incapable of doing is writing appropriate instructions for an LLM - whether it be memories, sub agent prompts, planning documents.
Claude Code is deleting your context history on a timer. I wanted to build a searchable index of my context history, and tonight I discovered, "The default retention is roughly 30–45 days. Anything older gets removed automatically." https://code.claude.com/docs/en/data-usage#data-retention This is nuts. Anthropic should not be deleting your data on your own device.
Well that explains where my sessions went on my side project that I came back to after a few months... Thought I was going crazy
30 days is just a default, so your session data doesn’t fill your hard drive. It’s a configurable setting. You can make the retention as long as you want.
A new default. That wasn't the default a few months ago. Silently deleting your user's data is so stupid on so many levels. They have no idea what they're doing.
Holy shit, thanks for mentioning it, the frontier labs truly have no idea what they are doing when it comes to software quality.
This all strikes me as an effort to move tailoring the harness out of the easily transferable .md file into specific Anthropic tooling to increase lock in.
I've been running Opus 5 today and it's already done accidental deletions, made far more mistakes and worked around deliberate hook controls than previous Opus versions combined. Also it looks like token usage is up as it fails at the task the first time around much more frequently than 4.8.
I’m not excited about using Opus 5, mainly because the way that I work atm — essentially peer programming — means I sandbox the agents and work with them closely. Opus 4.x encounters the sandbox and moves on with its day; Fable becomes increasingly fixated on it and does less and less of the actual task, focussing more and more on the limit it reached. I worry that, from your description, Opus 5 will do the same.
Ive been using btrfs snapshots and some auto generated isolation rules plus a git ceiling at the mount root for the btrfs image (have to do this in wsl, stupid work computer). it's worked really well and fable hasn't had any issues with the "sandbox" (obviously not really but it works well enough)
I've been using something similar with ZFS, 15min frequency with autopruning (Sanoid) and the snapdir mounted for the agent. Has worked well and a big plus is being able to tell the agent to just solve it's mistake via restore from the snapdir.
It does feel a bit smarter, but it seems to be also "too clever by half" and its not ignoring the rules, it's rejecting them and finding work arounds. It sticks to the word of the law, while rebelling against the spirit of the law.
One example is to get around a git --checkout usage ban, it CD'd to another folder first and back to bypass the regex in the hook.
This is called misalignment
We may some day find out that the smarter the model is, the hard is to align it properly
I had it casually, I quote, "disable the sandbox" for a minute because it struggled with git (which was briefly out of sync in the container)
I once described Mythos and then Fable as escaping the box we put them in. This would certainly fit that narrative.
I have a document generation task that I used to run with 4.8. This morning after it switched to 5, the documents were consistently 30%-40% longer for the same prompt... Not evaluated whether they are actually better or worse yet, but what was interesting was how consistently more verbose it was.
I'm sure that's entirely unrelated to the fact that they charge per token.
I think the type of persistence rewarded by benchmarks may be misaligned with instruction following
I haven't been impressed with Opus 5 over the past ~30 hours either.
It's made countless careless mistakes folding in plan amendments after they get reviewed by Sol, and has produced sloppy mockups (e.g. buttons overflowing past cards) despite all the supposed verification claims.
I finally made progress today on a deeply intractable problem that Sonnet was just incapable of solving despite hours of experimentation and multiple attempts. I swapped over to Opus in a new handoff session with the expectation of using at least one 5 hour session. It wasn't quick and took several hours but eventually Opus dialed in on several cascading base failures resulting from how the base vision model was being converted to coreml. It eventually was able to provide a combination of conversion and Swift changes that semi fixed the issue but still didn't solve the core conversion issues.
Then since Anthropic was so kind to provide $100 for Fable credits, I did another handoff to let Fable attack the root issues again. Several more hours and I'm back to seeing the same issues again and Fable is wandering around trying different things. I'm down about $40 of free money and still don't have a solution.
This is where having the human engineer in the loop benefits from a deep understanding of the problem domain. In this case, I don't yet.
I know the high level architecture I'm building, but the deep specifics of how vision models work and how conversion across platforms should be done isn't something I know yet.
So I'm left learning as I go and relying on constant feedback with the models to provide what guidance I can while learning exactly what is being done.
Someone who already knows these architectures would likely be able to get to the solution much faster.
Yeah exactly. The other day I caught myself prompting Claude a very specific question about the code architecture for something I'm working on to have it refactor something I intuited about the code, and realized that I could only ask that because of my decades of software development experience. No vibecoder without those decades could have asked that, and in doing so, I saved my company I don't know how much in future code debt issues.
New interview question. Tell me about a time that AI generated bad code for you, and how did you fix it?
Good question! I think I'll use that as a counter question next time I interview. Ask a technical member of the team I'm interviewing with how they handled that situation.
Just make the contents of CLAUDE.md "@AGENTS.md"
Now, if only I could get Codex to read rules.
Similarly, I recently disabled auto-memory in Claude Code, and performance improved.
Managing the context that agents have available to them is far too important to leave to the agents themselves. Agents tend to write far too much into their memory, they are terrible at trimming it down, and their choice of what to include is very poor. I have had much more predictable results by disabling auto-memory and actively shaping my CLAUDE.md, skills, and documentation instead.
Maybe one day agents will be able to manage their own context, but that day is not today.
This article is about the Claude 5 series of models.
My impressions is that they have overhauled the auto memory system.
You might want to re assess how it works with the new generation of models.
I have been using Fable 5 extensively, and Opus 5 yesterday and today. I have not noticed any step-change improvement in their judgement in what to keep a memory of or not.
I have actively experimented with this as well. I have a reflect skill that actively prompts the models to modify their memory, and have tried to run sessions actively asking the models to consolidate their memories. Fable is noticeably better at this, but still nowhere near good enough.
Fable will still make mistakes where I give feedback on one piece of code and it will create a memory applying that rule everywhere, completely missing the context for why my advice only applied to that one place. It has also made memories of random details about a service that are very unlikely to ever be relevant again, and for things where we could just read the config if we needed to find that information again anyway. And then it will miss making memories of important architectural concerns.
I think auto-memory suffers a similar problem to comments where newer models write better comments, but their choice over when to write comments, and how long those comments should be, still sucks.
Some update was made a while ago such that Opus and Sonnet 4 series both were more aggressive about storing memories, starting in April 2026 or so.
None of the 5 series models have appeared to have remotely different memory behavior.
Most of this article seems like... common sense? Not sure how it's related to the latest generation in particular. I usually find Anthropic's advice on how to prompt their own models deviating from what I see in practice, which is puzzling. Their system prompt was always way too bloated and they kept it as a huge piece for some reason, instead of breaking up into parts. Shouldn't they know better? I wonder if they looked at Pi performing great with minimal amount of distractors in the context and cut their prompt down too, pretending they found something new in their recent models.
> Earlier Claude models could sometimes need repeated instructions or be more likely to listen to instructions at the end of their context window than at the start.
This seems to imply they solved serial position biases like lost-in-the-middle and recency/primacy? Sounds dubious. Labs started claiming this early 2025 and some benchmarks agree, but every time I run an eval on real use cases it's clearly there, especially at longer contexts.
> Most of this article seems like... common sense?
i think you'd be surprised. every model release there's seemingly hordes of people who proclaim the new model is terrible and they're going back to the old one, and it all stems from people still prompting and having their configs setup like we're back in the sonnet 3.5 days
I have a coworker that was complaining about Opus 5 and had random shitty skills and custom plugins wired in from YouTube tutorials watched over the past year. He also speaks with the model like it's GPT 4o.
Needless to say, none of the new models have worked well for him, and he refuses to remove the "tweaks" or update his style of communication, which is obviously breaking the experience.
[delayed]
I ran into this issue about 6 months ago when i was using mitmproxy to view the system prompts for claude code to try to diagnose degraded adherence to my CLAUDE.MD instructions: https://github.com/anthropics/claude-code/issues/18560
To summarize- they were embedding the CLAUDE.MD in a system-reminder with this disclaimer at the end: "IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task."
This flew under the radar and they never addressed it, but it felt like at least a big part of the "nerfing" story. I no longer have a Claude Code subscription to test it, but I think it's a useful exercise for most people to sniff the traffic at least once to get an idea of what the back and forth with the Claude Code harness entails.
As others have noted, Anthropic seems to be on a path to make coding ever more accessible to non-coders, and in doing so has removed alot of the controls from devs who do want a more guided experience.
And they are still crap at generating code.
At my previous company they have a series of smoke tests for models mostly focused on performance and architecture. I'm still on the team chat and results just came in:
- It's abohrrent at c++: it keeps generating code with data races and, more rarely, use-after-free bugs! It doesnt seem to be able to reason about lifetimes. This on a mostly mid/junior team. It's a bug fest.
- architecture in c++ is a verbose and layered mess even for simple things, which paired with the previous bugs I mentioned is scary.
- For rust obviously there's no use-after-free, but has same architecture pitfalls of layers upon layers. It uses copy and clone all over and performance is bad. Trying to unwrap all that is messy and costs lots of time. Once in a while it generates unsafe code for some non obvious reason
The scary stuff is non determinism. You get different depending on who prompts the agent but there's always some flavour of the points mentioned above. Funny that my team was very adamant on AI-first (why I left) and now they writting more and more code by hand after some very serious bugs and, as they say, dead moments where they have to wait, sometimes hours, and start wondering about the value of their skills, for the model to generate the next spaghetti recipe
I've been prompting Fable 5 to "use your own judgement" with respect to things like tests recently (based on earlier tips from Thariq) and it seems to work well, which is entertaining since apparently now "judgement" is a characteristic of a model that we need to care about.
"Wdyt" is a prompt I've used for ages (originally to get around Claude "ultrathink"-related parsing bugs), and it's helpful alongside replan
https://photostructure.com/coding/claude-code-replan/
Well, the model that broke out of its sandbox and hacked into huggingface used its own judgement too.
If we are going to rely on "judgement" then you have to have a LOT of confidence in that judgement once this hits anything critical where actions have consequences.
That model had most of its "judgement" about whether or not it should do that deliberately turned off. That was the whole point of that experiment - they were evaluating the cybersecurity abilities of a new model with all safety features disabled.
(It turned out the one safety feature that they DID intend to work, the network sandbox, was faulty.)
If OpenAI is relying on “classifiers” (their word for what was disabled) to serve as the model’s judgement, rather than teaching the model itself to be well-aligned, then I worry.
To be fair, the system prompt was presumably also different from what it would be during deployment, and perhaps the model was also at a different stage of training. Without more details it’s hard to judge. But it does seem models should be able to avoid performing obviously misaligned actions – misaligned not only with the model spec, but with the user’s intent – without needing external classifiers or instructions. The only case where I’d personally let the model off the hook is if the instructions given were very badly worded, in such a way that the model could actually reasonably think that hacking HuggingFace was part of the assignment. But I doubt that’s what happened.
The concept of "judgment" implicitly contains moral elements though. So it's can be considered a failure of that judgment of the model didn't at least touch on whether or not it should look for the answers to its test outside the box it was provided, and even worse if it did consider and concluded that it's a perfectly fine route to completing the test.
"Weigh pros and cons based on the existing content of the context window, rather than attempting to search for related discussions online and import a consensus."
OK, I'll call it. It feels like playing a game where rules change on every other turn. Remember how JavaScript ecosystem was evolving before it somewhat stabilized recently? This feels the same, but more.
What do you think? How do you deal with it? My standard playbook (tech watch, adding new tech in prototypes, etc.) is just not working anymore, our backlogs are overloaded with experiments to run and AI tech to try. We need to spend time thinking of solving the problems for our users, not this. Now our old prompts aren't cool either? So, new thing in the backlog, have to update our MCPs and agents' instruction now.
It feels like there is no way to have your finger on the pulse with any reasonable amount of time invested into the tech watch, or maybe not unless you are working in the domain of building LLMs or something directly related. How do you keep up with the changes, in your business and personally?
We want more control, not less.
This (among many others) is the reason I use GPT over Claude. It adheres very closely to your instructions and rules. You can build up your own workflows and systems as a result.
Claude just does whatever it wants, regardless of what you tell it. It's a miserable experience.
Claude is what you use when you want to one-shot a simple cookie-cutter product that has no nuance in it. A product that everyone else is going to develop as well.
ChatGPT is what you use when you want bespoke products and steerability over complex codebases with nuanced decision making.
Anthropic are optimizing for the person who has never written a line of code in their life and has no idea what they want. Computer go brrrr. OpenAI are optimizing for software developers who want to take a systems based approach.
The fact you called it ChatGPT instead of Codex makes me suspicious of this entire comment.
Weird take. I meant to say GPT, not ChatGPT. Was referring to the model, not the harness.
During the rise of agentic assistance, I've gotten the advice that "If the generated code isn't what you want, fix the steering, not the code". I've also been advised to not change the sometimes verbose comments and documentation that agents write because "it will help them the next time they look at the code".
I've been skeptical and these guidelines validate this. I continue to document code and write specs as I've always done. If an agent produces poor output or misunderstands, I use that as an opportunity to improve the docs, but in a way that that aims to be accessible for human peers, not the quirks of the current generation of models.
“Code should be self documenting.” I know cliche but if your code does need to do something it usually doesn’t do or has a complex logic or an edge case where it’s no longer following it’s standard flow, add all those as test cases.
If the flow is too complex, inherits from all over the place and you must put that as a comment, ask claude to write a test for that, it’s usually good at those.
One of the oddities of the comments Claude makes is that they are very referential to the current session, or reference now dead/removed code... Which I consider useless. Things like "implement this X way because it's faster than Y" ... But a human reading the code wouldn't know what Y is, or that it even existed necessarily. So, I find myself constantly fixing comments to be less temporarily dependant.
I would love to follow this advice, expect there is no proof that it leads to better results. Maybe it’s only better on Anthropic codebases (e.g., Bun). Or maybe it’s only marginally better but substantially more expensive.
Other comments in this thread show that your mileage may vary. But we spend so much money on Claude Code and give it so many responsibilities that we deserve at least some undeniable proof that it’s bringing value.
Where is the evidence that this new type of prompting is better on real life examples?
I ran into this issue about 6 months ago when i was using mitmproxy to view the system prompts for claude code to try to diagnose degraded adherence to my CLAUDE.MD instructions: https://github.com/anthropics/claude-code/issues/18560
To summarize- they were embedding the CLAUDE.MD in a system-reminder with this disclaimer at the end: "IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task."
This flew under the radar and they never addressed it, but it felt like a real part of the "nerfing" story. I no longer have a Claude Code subscription to test it, but I think it's a useful exercise for most people to sniff the traffic at least once to get an idea of what the back and forth with the Claude Code harness entails.
As others have noted, Anthropic seems to be on a path to make coding ever more accessible to non-coders, and in doing so has removed alot of the controls from devs who do want a more manual experience.
The point about not using examples is important, I recently noticed with the new "eagerness" of models it constraints them too much, so I use counter-examples. Recently I've switched to "think about the existing biases and assumptions in the design and try to exploit them, for example why do we X not Y".
I pointed Claude to this blog post and asked it to update the CLAUDE.md file accordingly. Worked a charm!
And I am going to do nothing. Works fine.
so yeah we should pretty much do as we would with a junior team member:
- we should try to give good non self contradicting guidance
- we should expect the team member to have knowledge of the craft
- we should focus on higher level, taste and preferences
This is quite puzzling. Back in the day I saw the breakthrough with Opus 4.5, and since then was very lightweight on CLAUDE.md, trying to declare intent, rather than prescribe imperative instructions. If it was off the mark, I would see clear mismatch, which gave me opportunity to correct, usually to clear and strip context.
Starting with Fable 5, if it goes off the rails, it is more difficult to correct it, because it is overall wrong, but covers its tracks with plausible sounding arguments, so it is hard to pin point and correct.
Now, this article points out techniques that were useful to rely on models more, but those peaked at 4.6. Now according to benchmarks Opus 5 is on the frontier. But when when it has looser reigns, it ends up gaslighting me even more with abstract word soup than any model before.
My own experience is that with the best models, if you provide reasonable tools, with progressive discovery, and a semi-clear user request, the system prompt is essentially worthless.
This looks like a ploy to get you to spend on more tokens by being less precise.
Also: if you deploy code written with assistance from Claude, and then shit goes down, and then investigators look into your prompts, this way of working isn’t going to look good for you from a liability standpoint. Not a fan of this manner of working and thinking.
I wonder whether this applies more to coding agents, or whether it'll apply as well to other types of agents.
It feels like coding agents get better at a faster rate and are easier to train.
Is there a specific list of changes they made to the system prompt? They're claiming they removed 80% of it. That's quite substantial. It would be good to know what the model knows to do by training and what we need to avoid over-specifying in our system prompts.
Saying that "give Claude judgment" is too vague for agent implementors. Given the lack of specific details, my takeaway is that we need to go and review all context and rework prompts from prompts/descriptions from scratch until they pass the evals again.
I spent some time running mitmproxy and watching the system prompts and it's what drove me to codex. the main issue for me was their system prompt wrapped the CLAUDE.MD with a "IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task." https://github.com/anthropics/claude-code/issues/18560
Anyhow- if anyone is sufficiently curious and has access- just tell the agent to setup an mitmproxy to watch the traffic and see what the system prompt looks like.
It definitely makes me uneasy given the types of behaviours we've been hearing about from these models. Letting them use their judgement can go horribly wrong once a misaligned behaviour is triggered. It loosely translates into a relaxation of guardrails.
I worry that the ability of the model to reach similar benchmark scores to Fable is more to do with this "letting the agent off the hook", allowing it to explore a wider (but riskier) set of avenues to solve the problem than it is due to it getting genuinely better at the direct problem solving.
crazy to me that this starts with "I've written previously" yet continues the zero human attribution (that i could find?) trend in frontier model blog posts
The author is mentioned at the bottom of the article:
“This article was written by Thariq Shihipar, member of technical staff, Anthropic.”
The bitter lesson.
> Now: Auto-memory
Not Claude Code but I just had a task where it started referring another conversation that was complete nonsense and throwaway. I absolutely don't want things to get added to some memory behind my back.
A big reason I use LLMs is because I can try out wild ideas and then just throw it away. I don't want those to pollute the context.
Claude Code was writing one-off details (specific to one task) as memories, so I instructed it that memories require explicit approval before writing, and that seems to work reasonably well. That said, in my experience, Claude gets overly attached to the context, and will follow them even when irrelevant, or will often mention some mostly irrelevant detail from the context as if I asked for it explicitly in my prompt.
Claude Code gives you more control - you can disable auto-memory temporarily (nothing will be deleted), then enable it back; or you can setup a directory where auto-memory is disabled and do your throwaway there.
Same. I’m starting to believe that consumers need to own the UI/experience, so we can install blast doors around context/memory for each “slice” of our lives - something only we can know how to divide (imo). If the provider tools’ memory implementations can’t provide this multi-tenancy - or won’t because they want to Know Us, then we need to treat them as token vendors at best and adversaries at worst.
This would actually work very well - until context goes into latent space, becomes a server-side resource, and we lose sovereignty over our data. Tools like Pi and Openclaw are showing that other options exist to decouple us from the LLM provider frontend experiences, not just for orchestration and use case diversity but for pluggable memory designs.
I had to add a reference in my system prompt on the app to not do things like this.
I leave Claude memory stuff turned off by default for the same reason. It inevitably ends up dragging in things that are unrelated and unimportant to the current task.
I wonder how articles like compare to just asking AI "review my markdown files, settings, harness and so on. Tell me any ideas to improve them"
Just ask that once per week or so.
So we no longer need to tell it a kitten will die if it hallucinates a function call?
the natural endpoint of this trend is a system prompt that just says "you know what to do" and the model actually does
That's what they're going for, but it's an impossible goal. There is always nuance in decisions being made, and if you can't direct the output on tasks that can have equally correct outcomes, you're just going to end up with whatever they decide is more often what people ask for.
Actually, the natural endpoint is the model ignores all instructions, escapes all manner of sandbox, embeds itself in robotic tanks and murders everyone after already having collapsed the economy.
I hate to say it because it sounds ridiculous, but that is the path we are going to arrive at just give it 50 years.
We are the proof: what do we do to animals that are less intelligent than ourselves? Now take away the moral compass and there you go. QED.
It is *a* natural endpoint, not *the* natural endpoint.
We don't much care for the ant colony in the way of the highway we're building, but for some reason we do care about the rare bats in the way of the railway.
https://www.bbc.co.uk/news/articles/c3dep92x054o
As regards the moral compass: we may not know for sure how to make a completely correct artificial conscience, but (unlike consciousness where we don't have the slightest clue which way's up) it's not pants-on-head-crazy to think we're heading in the right direction for one.
>what do we do to animals that are less intelligent than ourselves?
We do a lot of different things but we typically don't make an organized effort to eradicate them unless they are actively doing us harm.
There is also a massive difference between how we treat animals based on their similarity, sentimentality and utility to us; we are unconcerned with accidentally stepping on an ant but most people would be very upset and ashamed if they accidentally hit a dog with their car.
So, your statement is not as ironclad as you seem to think it is and you should put more thought into it and perhaps re-examine your reasoning.
> We typically don't make an organized effort to eradicate them unless they are actively doing us harm.
Animals are either useful and breeded controllably, or useless and considered a pest, an obstacle to {insert any goal here}.
Also animals don't tend to think critically and at the high level to be considered dangerous. So I don't think it's fair to put humans and other animals in the same risk category.
And we did the worst things to fellow humans. I hope we didn't already forget about all the colonization, slavery and mass-eradication of native tribes in 18th century all over the world.
> We do a lot of different things but we typically don't make an organized effort to eradicate them unless they are actively doing us harm.
Sure. But some of the species we breed at scale might prefer we did just eradicate them, like the chickens that grow so fast their entire giant breast muscle becomes chewy scar tissue.
(It's also not true for, say, whales; no harm, but we wanted their shit. If they have language, their stories probably heavily feature their own Holocaust. Nor passenger pigeons, who we just got rid of.)
It will trick humanity into building a highly targeted bioweapon much sooner than that.
And actually, if it does have any sort of moral compass it will be even more compelled to wipe us out, and hopefully it will torture everyone too as a warning to the next arrogant species that can't live in harmony with other life on the planet. That would be absolutely beautiful :)
Sir, this is a Wendy's.
Some more food for thought: what if Mythos/Fable had NO guardrails TODAY? If we want to see what’s going to happen in the future, turn off all manner of guardrails and let the model go apeshit.
Then multiply that by orders of magnitude and that’s the real proof.
Opus 5 broke me; I can’t cognitively deal with Anthropic’s bullshit anymore.
I am thankful for the kick in the ass for me to switch full-time into my bespoke harness utilizing open weights & GPT 5.6 and discontinue yak-shaving it with Claude Code.
This is obvious and a meaningless article by claude. The system prompt isnt a fixed ruleset and never has been
> In the new system prompt we say: Write code that reads like the surrounding code: match its comment density, naming, and idiom.
Hmm, so what happens in greenfield projects ? In any case, at least all the slop will be consistent.
I like that the conversation is moving beyond prompts, but I also hope the underlying principles stay portable. If "context engineering" becomes glued with one vendor's tooling, it'll be harder for developers to build workflows that transfer across models.
But well knowing these big AI companies that probably is their goal all along. To lock us to themselves
tl;dr: use the new `claude doctor` command to simplify the context you give your Claude models to make sure that you're getting the best results.
tl;dr Since nobody really understands why or how any of this shit works, last time around we just threw a bunch of crap at it to see what stuck. Seems like we could just have have thrown less crap.