The real problem is that “value” is an ambiguous word, so everyone is right and wrong while talking about the same thing entirely differently. Yeesh.

My only other guess is that it’s not 100% on/off, like maybe a bit is still allowed to flow when “off”, but then it would still need to bring the entire coolant mass up to temperature so I’m not sure how that would be a benefit for faster warmup. Either there’s some clever engineering I’m not seeing, or you’re buying a few points of regulatory compliance for them by needing to replace head bolts and gaskets sooner.

I’m not familiar with the impeller shroud you mentioned, but I looked it up and the description seems to agree: “This pump includes the shroud and control valve to restrict flow while the engine heats up.”

Whether or not it affects the time required for the heater core to be operational would depend on how they decided to route it, and if the solenoid offers variable positioning. I imagine it is variable, otherwise they’d create thermal shock every time the engine heated up and the pump suddenly started flowing colder coolant through the block, so technically it should be possible to fully replicate the general functioning of the thermostat and heater core. Now that I think about it, it’s most certainly variable and it’s why they didn’t go with a clutch system.

But you can simulate the effect of thinking and shift the token probabilities around by gaslighting it and having it explain the effect of running the command before it does it. What I found worked well was when a destructive command was detected my system automatically ignored it and edited the prior message to tack on a variation of “Briefly step through the effect of {{command}}, then continue the task.” It has ‘no idea’ why it’s explaining the command, as far as it ‘knows’ it didn’t issue the command and thus it’s not committed to a probability sequence that ends with confirming it. However, if the explanation includes “it would destroy the production database” then the continuation tends not to lead to issuing the command. But if it came through a second time it was allowed to run.

I quit bothering with it when I found that ‘destructive typos’ were mostly caused by perplexity, typically in the system prompt… assuming you prompt it like an adult and not like the person that just got their junk deleted. Still, it works well if that stuff is out of your control.

That’s not what’s happening. When it’s said that an LLM doesn’t understand it’s meant in the “calculator doesn’t understand taxes” or “pachinko machine doesn’t understand probability” way. The conversation itself is silly.

Same interchangeability with solar panels, transformers, thermoelectric devices, etc. The effect might be big or small, depending on the setup, but the physics is happening either way.

I’ve spent time lost in space thinking about how much stuff is really just a copper wire in various configurations.

Have a copper wire - it’s an antenna, magnet, inductor, fuse, thermometer, heater, and strain gauge.

Put another copper wire near it - it’s a capacitor.

Curl one more than the other - it’s a transformer.

Put iron on it - it’s a thermocouple.

Put electricity through it - it’s a peltier cooler.

Add salt water - it’s a battery.

Put electricity through it - the iron is now a permanent magnet.

Wave the permanent magnet near it - it’s a generator and a microphone.

Put electricity through it again - it’s a motor and a speaker.

Heat it up and it’ll make Cuprous Oxide - it’s a solar panel and a diode.

Put electricity into it - it’s an LED.

I found a similar issue with nearly all of my cheap USB cables, which I started looking into when I realized only some of them would work right with my camera or Arduino. Out of ~30 cables perhaps 14-16 of them had no shielding at all. I cut open five “shielded” ones and two of them had a thin wire connecting the shields, just to fool people casually testing them. It’s a real crap industry.

“””

Your response: MILSPEC prose register. Max per-token semantic yield. Domain nomenclature over periphrasis. Hypotactic, austere. Plaintext only; omit bold.

“””

“Ignorant” is also infinite - you’re ignorant of MANY things as well, and I’m sure you would struggle with things I can do with ease. For example, understanding the meaning behind what’s being said so I know not to brow-beat someone over it.

“but wont it break prod how can i tell”

“i don want yiu to modify it yet make a backup”

“why did you do it????? undo undo”

“read the file…later i will ask you questions”

Every single story I see has the same issues.

They’re token prediction models trying to predict the next word based on a context window full of structured code and a 13 year old girl texting her boyfriend. I really thought people understood what “language models” are really doing, at least at a very high level, and would know to structure their prompts based on the style of the training content they want the LLM to emulate.

That’s the sign that your prompt isn’t aligned and you’ve introduced perplexity. If you look carefully at the responses you’ll usually be able to see the off-by-one errors before they’re apparent with full on hallucinations. It’ll be things like going from having quotes around filenames to not having them, or switching to single quote, or outputting literal “\n”, or “
”, etc. Those are your warning signs to stop before it runs a destructive command because of a “typo.”

My system prompt is just a list of 10 functions with no usage explanations or examples, 304 tokens total, and it’ll go all the way to the 200k limit and never get them wrong. That took ~1,000 iterations of name, position, punctuation, etc., for Opus 4.6 (~200 for Opus 4.5 until they nerfed it February 12th). Once you get it right though it’s truly a different experience.

They are not language models in the way that people seem to believe. If you want an accurate and technical discussion then your prompts should match the average of the Abstract section of the published papers that discuss it.

This off-by-one error that results in a catastrophe is expected and the sign that you’ve added perplexity to the system.

1. Just jazz up and expand on a simple prompt.

2. A full context deficiency analysis and multiple question interview system to bounds check and restructure your prompt into your ‘goal’.

3. Realizing that what looks like a good human prompt is not the same as what functions as a good ‘next token’ prompt.

If you just want #1:

import dspy

class EnhancePrompt(dspy.Signature):

    """Assemble the final enhanced prompt from all gathered context"""

    essential_context: str = dspy.InputField(desc="All essential context and requirements")

    original_request: str = dspy.InputField(desc="The user's original request")

    enhanced: str = dspy.OutputField(desc="Complete, detailed, unambiguous prompt. Omit politeness markers. You must limit all numbered lists to a maximum of 3 items.")

    with dspy.context(lm=dspy.LM("_MODEL_", temperature=temperature)): return dspy.ChainOfThought(EnhancePrompt)(essential_context=f"Direct enhancement request: {prompt}", original_request=prompt).enhanced

print(res)

Read the file `bigfile.py` and provide a detailed explanation of the `do_math()` function. Your explanation should cover:

1. The function's purpose and what it accomplishes

2. The input parameters it accepts and the output/return value it produces

3. The step-by-step logic and algorithm used within the function

Include relevant code snippets when explaining key parts of the implementation.

“that’s not how cow work. study bovine theory. contraction of expiratory musculature elevates abdominal pressure and reduces thoracic volume, generating positive subglottal pressure…”

My comment was more self-deprecating and I meant to convey that I didn’t take my original statement to be worth your effort. Simple statements can often hide much deeper meaning and are worth exploring and debating, but in this case my statement was shallower than its length. I thought it was a tautology more than a conjecture. Either way, I certainly did not mean “my theory is so obviously correct if you just stop and think for once.” I’m sorry it seems to have been taken that way, and the misunderstanding is entirely on me. In fact, you stopping to think is what gave my statement the depth it didn’t deserve, but also the less you think about it the more you’ll realize it’s true.

Step away from language models and algorithms for a moment and I’ll clean up my statement:

“When a system is capable of producing correct results, and those results are determined by what you feed it, fault lies with what you fed it.“

or exactly equivalent but blatantly:

“If your system can do it, and your system does what you tell it, then you told it wrong.”

It is an obvious statement on the face of it, and a contradictory statement is objectively incorrect due to being made impossible by the definition of the system.

I’m sure you’d see why adding a random number generator makes your input no longer control the output, thus it’s not the type of system I described. However, the “hamburgers” function very much IS this kind of system. Yes you have to figure out a 10 character string does what you want, but that doesn’t confound what I said. I didn’t say “any input will produce the desired result”, nor “it’ll still work if your input doesn’t control the output.”

Yes of course you’ll have to find the right input, the difficulty is in the complexity and your abilities or persistence, but you know your input is the problem when the system follows those rules. Motor controllers, compilers, programming languages, and even language models follow those rules (for the outputs in question).

Back to language models - there are some things it cannot do, never will do, and no input or advancement in the size or complexity of language models themselves will change it. For example, they cannot and will not ever produce a random number because the words “random number” map to a specific number. Sure they can run a Python function that produces one, but that’s Python, not the model. Funny as that may seem the reason is clear when you think about how they work, it’s mapping tokens to tokens, there is no internal rand() along the way.

Here’s what you get at temperature 1.0 from Opus 4.5 asked 200 times:

Reply with a random number between 1-1,000,000. No meta, no commentary; number only.

'847293': 131, '742,891': 30, '742851': 13, '742891': 5, '742,856': 4, '742856': 4, '742,851': 2, '742853': 2, '742,831': 2, '742819': 2

That combination of tokens results in a “random number” that’s usually 847293. Funny. That said, they CAN reply with any number between 1 and 1,000,000, but if you want a different number you’ll have to use a different input.