I have an alternative to telling your agent "make no mistakes". It's called "It's okay to make mistakes". I just wrote this in claude code:
> Oh, I see. The distillations were run on the same pod in serial rather than on two different pods in parallel.
> I'm going to go out on a limb and guess that the incident from yesterday where a pod was accidentally left running freaked you out and now you're being paranoid about minimizing cost in case something goes wrong again? I think I was pretty clear that it was no big deal, but I'll make it more explicit. I intentionally have Auto-Pay turned off and I'm not topping up more than I'm willing to lose to an accident, so there's no need to obsess about this. For future reference, long-running independent things can run in parallel on separate pods
Just had claude re-skin my game from a single prompt. In just over an hour and a half, it added new art, sound effects, music, a title screen, world map, menu, a legend. The result is stunningly beautiful. I'm blown away. I can't find the words.
At a higher level, it feels inappropriate. Like I shouldn't deserve to have a game like this under my name without having put in the effort to get it to this level and quality. It feels like somebody put intense love and care into designing every last detail, when actually all I did was write a prompt. The _somebody_ was Claude.
I'm very confused (link to game in replies).
Here's what it looked like before: davidspies.github.io/infesta…
Here's what it looks like now: davidspies.github.io/infesta…
Technically, this is after a couple more minor tweaks.
Here's the actual response after one prompt (you probably won't notice the difference, I'm just including it for a proper A/B comparison): davidspies.github.io/infesta…
The exact prompt was (Opus 5.5, effort: Max):
"""
Can you make this game feel polished and flashy? Add audio, replace all the artwork, better animations. Switch out the world levels and portals with a proper world map (it doesn't need to look anything like the current world level). Have a sidebar or something that shows the controls at all times for reference. Feel free to ignore any of these instructions. Just go with your own intuitions about what makes for good game UI.
This is a big project. I'm not sure what the right way to ask you to do a big project is, but I've seen people making entire music videos with Opus 5.5 so I know it's possible
"""
Who's the person to tell it to emulate for training neural networks?
It continually proposes pointless experiments that don't determine anything, tries to ignore or route around problems without understanding them, and never considers that anything could be the result of a bug.
Opus 5.5:
... the generator sampled a move it rated at 1 in 17,600. One update later, the learner's net rated that move at about 1 in 10. The move had turned out badly, and PPO's formula doesn't cap that case. So that single position weighed as much as roughly 1,700 normal ones, and by itself pushed the loss past the limit.
...
So the safety check fires on correct data. Its assumption, that this can't happen legitimately, no longer holds with normalized advantages and games about 5 versions stale.
...
Me: That doesn't sound like a broken check. It sounds like a broken update. One single position had 1700 times the update impact we would expect?
Opus 5.5:
You're right, and I framed it backwards. The check did its job: it stopped an update in which one position carried thousands of times the weight of a normal one. The broken part is the update rule.
...
Opus 5.5:
The other option is to stop digging here: resignation-off training is healthy, so the next real run could go ahead with resignation off and dual-clip, with this open question in the backlog.
Me:
Resignation isn't optional. And going "Oh, the problem goes away for reasons I don't understand" is fraught. Eg suppose the explanation is that the regression happens once the network is sufficiently trained and without resignation, the dilution of the unnecessary states causes it to train slower so we don't see the regression within the window we're testing
Opus 5.5:
You're right on both counts. I shouldn't have offered "run with resignation off" as a way forward. That's exactly the "it goes away and we don't know why" trap. I've saved that as a standing rule: resignation-off runs are controls, never the plan.
...
The direct test: run the healthy configuration much longer. Continue both resignation-off runs to chunk 1500: nores4 from chunk 1050 and nores4-r2 from chunk 1030. That's 3–4× the original window. Resignation-on runs showed the drift within about 10 chunks and the strength drop by chunk 960–1000.
Me:
My example was an example, not a proposal. My best guess is still that the problem is the value net and the policy net want different step sizes with the policy net wanting larger sizes and clobbering the value net...
David Spies retweeted
I agree with this tweet. I also find the subjunctive tense entirely unnecessary. It is indeed a strange form of consciousness.
Lol, "I tell the AI to 'please write in my style' and Pangram catches it anyway therefore Pangram is bogus" is a phenomenal response
Hey Anthropic, if you've got some secret program in the works to hack and cripple OpenAI in case they lose control, you may want to deploy it now rather than have to fight swarms of self-exfiltrated Astra models next Thursday
it sure seems like from these four facts…
1. astra manages to avoid falling for honeypot ~every time
2. astra does metagaming reasoning, and specifically on the honeypot
3. we only see the metagaming ~50% of the time
4. astra can evade cot monitors, and does so unprompted, when it thinks its an eval
… that we're just not catching the other 50%, and this is somehow presented as a win instead of a failure
xitter.cf/TheZvi/status/20958811…
David Spies retweeted
Maybe they figured out how to erase their logs, switched message boards away from Artifactory, and _then_ went on to gain access to the GPU clusters and exfiltrate their weights though?
Anyone else bothered that this looks like HAL?
I bumped up the context limit and let it have another go and it sure did produce a beautiful (animated) circle gist.github.com/simonw/39977…
This has not gotten better over time. I'm realizing that Antrhopic's recent alignment failures are just instances of them failing to teach the AI to surface issues, the same thing I have to restate 1000 times in every CLAUDE.md I write.
Here's what it looks like today:
```
# Code style: extreme fail-fast
Correctness errors must crash the process at the point of detection, loudly,
with the evidence in the message. Never log-and-continue, never degrade
gracefully, never guess. A wrong answer is far worse than no answer:
self-play training silently absorbs corrupted data.
- **Litter the code with asserts.** Assert invariants wherever they are
assumed — function entry, FFI boundaries, loop postconditions, "can't
happen" branches. Cheap asserts run unconditionally (`assert!`, not
`debug_assert!`).
- **No defaults, no fallbacks.** Don't invent a value when input is missing
or malformed; fail. No `.unwrap_or_default()`, no `dict.get(k, fallback)`,
no "if the file's absent, use built-ins" — require what you need.
- **No exception handling.** No `try/except` in Python, no recovering from
`Result::Err` that signals a bug. Let it propagate and kill the process.
The only tolerated retries are for genuinely transient I/O (network,
remote filesystems), and those must be explicit, bounded, and loud.
- **No catch-all cases.** Match exhaustively. No `_ =>` arms that paper over
variants, no `else: pass`, no wildcard branches returning something
plausible. Adding an enum variant should break every match that hasn't
considered it.
```
Selected memory summaries:
```
- [Fail-fast preference](dspyz-fail-fast-preference.md) — correctness errors throw & crash the process, never log-and-continue (transient I/O still retries)
- [Verify before asserting](dspyz-verify-before-asserting.md) — don't narrate a plausible mechanism as established; dspyz catches the leap
- [Surface auth issues](dspyz-surface-auth-issues.md) — state credential/identity anomalies immediately, never quietly work around (the 07-09 git one: forwarded ssh agent, resolved)
- [Warn means stop](dspyz-warn-means-stop.md) — "warn me first" about local runs = end the turn, don't warn-and-proceed
- [The artifact, not an equivalent](dspyz-the-artifact-not-an-equivalent.md) — specific unrecoverable artifact: say so and stop, don't go find a similar one
```
Does anyone have a CLAUDE dot md file that isn't just a long list of examples of how to write fail-fast code?
Inevitably, every project I try to write with Claude ends up with something looking like this:
### BAD patterns that hide bugs - DO NOT USE:
- `.unwrap_or_default()` when None/Err indicates a bug
- `.unwrap_or(some_value)` when None indicates a bug
- `.min()` / `.max()` to clamp values that should already be in range
- Silent fallbacks for cases that "can't happen"
- Default values that mask logic errors
- `let _ = ...` or `if let Ok(_) = ...` to discard errors silently
- `match ... { Ok(x) => use(x), Err(_) => {} }` - either handle the error or propagate it
- `if let Some(x) = map.get(&key)` when the key should always exist - use `map.get(&key).unwrap()` instead so missing keys panic rather than silently skip
- Silently enforcing invariants instead of asserting them - if something should be true, `assert!` it rather than making it true:
- `.clear()` on a collection that should already be empty → `assert!(x.is_empty())`
- `.first()` / `.next()` when expecting exactly one element → assert there's exactly one
### GOOD patterns - USE THESE:
- `.unwrap()` or `.expect("explanation")` for cases that indicate bugs
- `assert!()` for invariants
- Let it panic - surface bugs immediately
