br3nt’s Stuff

flOw, the Flash game that lost its levels

2026-10-05T09:00:00+10:30

I was watching YouTube and came across this /noclip documentary on thatgamecompany, Flower, Flow & the Origins of thatgamecompany. It interviews Jenova Chen, who founded thatgamecompany, the studio behind flOw, Flower, Journey and Sky.

He talks about moving from Shanghai to the US to study at USC’s Interactive Media program, because there was no game industry in China doing the kind of games he wanted to make. There he worked with Nicholas Clark, a fellow USC student who co-created flOw with him, and Austin Wintory, who wrote the music. His lecturers pushed him to get creative, and in that time he made small experimental games like Cloud and flOw.

flOw was part of his master’s thesis, Flow in Games. You’re a small creature starting out in the shallows. As you eat, your creature grows longer, with more segments. As you go deeper you meet other creatures that try to attack and eat you. The point of the game was to let the player choose their own difficulty, by choosing when to sink down or swim back up. That was the point of the thesis: let the player steer the difficulty so they stay in the zone. A year later flOw became thatgamecompany’s first PlayStation 3 game, and the studio went on to make Flower, Journey and Sky.

I wanted to explore his work, and flOw seemed an easy enough entry point. It was a Flash game, so it should be on archive.org or somewhere similar.

A black void

Like I experienced with The Space Game, when I played the game from archive.org, it didn’t work. I was greeted by a black void with some glowing dots in the background. At first I didn’t realise anything was wrong. I could steer the creature with my mouse, but I couldn’t work out how to play. There wasn’t anything to do. I tried swimming towards the glowing dots, but nothing reacted.

And so began my journey of getting the game to work!

Restoring the game

Jenova Chen’s own flOw page is still up, but its “Play flOw online” link leads to a site that can’t be reached.

Claude helpfully read the SWF and found the answer in a couple of minutes. On startup, the game loads levels.xml along with its other assets. If those files aren’t sitting next to the SWF, the game doesn’t know what to draw.

levels.xml describes each level in the game, including its background colour, its food, its creatures and its bosses:

<Level bgColor="0x008DD8" levelSize="400">
  <SpawnFood num="15" foodType="1" hpMin="15" hpVar="10" />
  <SpawnFish num="2" numSegs="3" maxSegs="16" randEvolve="0" segLength="15"
             speedMin="60" speedVar="5" turnMin="8" turnVar="3" panic="true" />
</Level>

The game also streams its music, one MP3 per level and one per sound effect.

The good news is that every file is still on Jenova Chen’s server. The Wayback Machine even has the original ActionScript source from April 2006. Claude downloaded core.swf, levels.xml and the 41 MP3s into one folder, served it locally, pointed Ruffle at it, et voilà! The game sprang to life!!!

Compared with bringing back The Space Game, where we had to fake a whole server, this was a five-minute fix.

A tribute page

It deserved more than a fix, so I made it a tribute page where you can play it.

The page is styled like the game. It starts with the iconic colours from when the game first loads, then as you scroll, the background gets dark and eerie in the dangerous depths. Glowing particles pop in and out, and blurred creatures drift on a layer behind the page, the way the next level down shows through in the game. Just like the game, you see hints of snakefish, jelly rings, and once you’re deep enough, a manta. The page is somewhat interactive too. If you’re on a computer, a little creature follows your mouse and eats the food floating around the page.

I really appreciate the design aesthetic of this game. The blurred layers below hint at what you’ll discover next, and encourage curiosity and exploration. You feel anxiety and excitement as you see large, potentially dangerous creatures lurking below, and wonder if you can take them on head first. The way the creatures move, and the way you grow as you eat, give a lovely sense of naturalness and connectedness to the environment. You feel part of an ecosystem.

I hope you love this one as much as I do :)

▶ Play flOw →

Source: github.com/br3nt/flow-tribute

Resurrecting The Space Game, a dead Flash game, by faking its server

2026-09-10T08:00:00+09:30

The Space Game is one of my favourite Flash games. You mine asteroids for minerals and build out your base with solar stations, lasers, and missile launchers to protect yourself from waves of pirates that warp in to attack. The lasers use up your energy reserves, and building and missiles cost minerals. A wave or two of pirates could easily overwhelm your base. The game mechanics were simple but addictive, and I loved the vector style art and the soundtrack.

The game was released in 2009. Coding and artwork were by David ScottCo-founder of Casual Collective with Paul Preece. Made Flash Element TD in 2007, then The Space Game and its Missions follow-up. Casual Collective became KIXEYE in 2011.Casual Collective in 2009, Wayback Machine KIXEYE wiki, David Scott The Space Game on Kongregate from Casual Collective and the music and sound effects by Somatone. Later the same year came The Space Game: Missions, expanding the original game with a campaign.

When Flash died, so did the game. Most Flash games can run on Ruffle. Unfortunately, The Space Game starts to load but then displays the error:

Unable to load game. Please notify www.casualcollective.com.

The archived SWF is not the game

A copy of the game is made available on archive.org and Kongregate. Both sites load the game using Ruffle. Both then print “Unable to load game. Please notify www.casualcollective.com.” and stop. A 2021 thread on r/FlashpointArchive says the same thing: the SWFs pull their content from URLs that went dark, and Flashpoint Infinity could not run them either at the time.

I’ve been wanting to replay this game forever. My own Downloads folder had a copy I grabbed in 2021, sitting next to two Ruffle nightlies from the same year. So I had tried this before and not got far.

I’ve had a lot of luck getting Claude to help me get old games running on my Mac, so I figured it was the perfect AI for the job!

Claude quickly realised the SWF being run on archive.org was just a loader stub. The SWF was only 16 KB. I asked whether Ghidra could decompile it. Claude was already many steps ahead of me. Ghidra doesn’t do ActionScript, so Claude had picked JPEXS Free Flash Decompiler and followed up that the stub was making a POST to widget.casualcollective.com/load, and the reply it expected was two fields, w1 and w2. w1 is a URL for a “widget” wrapper SWF. w2 is an API base URL. The stub is a bootstrapper for a server that has been off for a decade.

So two things became apparent: we need to mock the web server the SWF is expecting to communicate with, and we need to find the actual game!

Finding the actual game

Of course, the Wayback Machine had it! storage.cloud.casualcollective.com/zones/pub/10/thespacegame.v83.swf, 1.9 MB, captured in 2019. The widget.swf wrapper was there too, from 2017.

Running the 1.9 MB game SWF directly in Ruffle, however, gives a blank white screen. Forever. A Ruffle bug?? “This SWF renders blank in Ruffle” is a common report on Ruffle’s issue tracker, usually a missing ActionScript feature. Another dead end.

Reading the wrapper

The widget fetched by the loader is 740 KB of obfuscated ActionScript 2: control-flow flattening, junk constant pools, the works. Claude wrote a small script to resolve constant-pool references in the P-code so the decompiled output read as something close to source. That recovered the entire boot sequence.

The widget’s protocol starts with a POST to <api>/pub/session/setup?gid=10 and gets a JSON response containing the following:

result must be 1, or the widget gives up.
swfs.base, swfs.game and gamev combine to give the URL of the actual game SWF.
cls is the player class, where 2 means member, which unlocks members-only content.
pd is saved player data as key value pairs like k=v,k=v.

The widget then POSTs to session/start and levelStart and ignores the replies, then loads a stinger (the Casual Collective logo animation), then a splash screen, then the game.

Then the widget and the game perform a handshake.

The game side looks like this:

var hss = random(9999999);

function CCHandshake(n) {
  if (n == hss / 11 - int(hss / 11) + hss % 11) {
    this.hsok = getTimer();
    delete this.CCHandshake;   // one shot
    delete this.hss;
    return true;
  }
  return false;
}

function CCSetup() {
  _root.setupLevel = function (n, showReminder, sameseed) { ... };
  _root.showMenu = function (n) { ... };
  _root.gotoAndStop(2);        // frame 2 is the main menu
}

And the widget side, from its “Run Game” step:

TraceLocal("Run Game:" + gameswf._name);
var h = gameswf.hss;                       // reads the child's variable
if (gameswf.CCHandshake(h / 11 - int(h / 11) + h % 11)) {
  TraceLocal("HS ok");
  topOptions.UpdateVolume();
  gameswf.CCSetup();
  removeMovieClip(GameSplash);
  topOptions.SetForStart();
  txtStatus.text = "Handshake OK:" + ...;
} else {
  TraceLocal("HS FAIL");
  txtStatus.text = "Handshake FAIL";
}

The handshake goes like this:

The widget loads the game SWF into a child movie clip inside itself.
On startup the game picks a random number up to 9,999,999, and stores it as a variable on itself: hss = random(9999999)
In Flash a parent can read its child’s variables directly, and both files come from the same domain so the sandbox allows it. The widget reads the game’s hss.
The widget runs the formula on that number and calls the game back with the result: game.CCHandshake((hss / 11 - int(hss / 11)) + hss % 11)
The game runs the same formula on its own number, compares, and returns true, or false if the handshake failed.
On a successful handshake, the widget calls gameswf.CCSetup(), otherwise the game remains on the white screen indefinitely.

I’m not sure why the widget, rather than the game, validates the handshake. It seems anyone with the actual game could just call gameswf.CCSetup(), and the game would run. I would have thought the handshake should be validated in gameswf.CCSetup(). However, the wrapper also provides the API to correctly fetch data from the server and set game variables required by certain features of the game.

That API is the CCAPI object the widget builds while the game is loading. It carries the methods the game uses to reach the outside world: GetPlayerClass for the member check, GetPersistantData for the save, LevelStart, LevelUpdate and SendStat for reporting progress and scores, and MoreGames and VisitStore for the buttons that link back to the site. The game never talks to a server itself. It only ever talks to this object.

Mocking the server

We now know the entire protocol required to run the game correctly.

To keep things super simple, I instructed Claude to mock the server using a JavaScript Service Worker. Service Workers are able to intercept any web request a webpage makes, which is perfect for mocking!

So Claude wrote the service worker. About 150 lines: the load reply, the session/setup JSON, session/start, player/data for saves, and result=1 for anything else it did not recognise. The page tells Ruffle, through its urlRewriteRules, to send requests for the two dead hostnames to the worker instead. The loader, the widget and the game run unmodified.

The setup handler looks like this:

if (path.endsWith('session/setup')) {
  const cfg = {
    result: 1,
    cls: 2, pms: 1,                            // player class 2 = member
    pd: await loadPd(gid),                     // saved player data, "k=v,k=v"
    seed: Math.floor(Math.random() * 999999) + 1,
    swfs: {
      base: 'http://storage.cloud.casualcollective.com/zones/pub',
      stinger: '/stingers/ccblocks.swf',
      game: `/${gid}/${game.stem}`, gamev: game.ver,   // /10/thespacegame, 83
    },
    // ...and a dozen fields the widget reads but never needs
  };
  return new Response(JSON.stringify(cfg), { headers: { 'Content-Type': 'application/json' } });
}

The next gotcha we ran into was a hang at “Loading: 89%”.

It turns out the widget’s preloader waits for getBytesLoaded() == getBytesTotal(). Ruffle only ever satisfies that condition for an uncompressed child SWF. The original CasualCollective server served a compressed version, which is the version the Wayback Machine and Flashpoint hold. So the service worker decompresses the file and stores it as FWS, and the preloader finishes.

Finally, the main menu came up and the game was fully playable!

Getting the Missions expansion working

Missions is an eight-mission campaign with difficulty multipliers, Easy at 1x through Normal 1.5x, Hard 2x and Crazy 3x, plus EMP, Super Miner and warp jumps.

Missions is not on the Wayback Machine. Every mirror I could find, Newgrounds and freewebarcade and flashghetto, serves the same 16 KB loader stub. Google’s AI answer for the problem was “use Flashpoint”, which is true and unhelpful when you want the file.

Claude found the way in. Flashpoint’s game submission system has a public API at fpfss.unstable.life/api/games, and each game record names its data pack under download.unstable.life/gib-roms/Games/. Both packs downloaded and matched their published sha256.

The Missions pack had tsgmissions.v16.swf, 2.9 MB. It also had Flashpoint’s own reconstructed setup.php covering eight Casual Collective games, which answers the same questions the service worker does, plus the Casual Collective intro stinger and the menu background art.

Flashpoint handles members-only content with a patched game SWF, whereas the service worker reports class 2 and leaves the game binary untouched.

Saving progress

The pd field in the setup JSON is the save. The game asks the widget for it through CCAPI.GetPersistantData(), and when something changes, the widget POSTs the whole string back to player/data. Casual Collective must have stored it against your account. The service worker stores it in the browser’s Cache Storage, one entry per game, and hands it back on the next session/setup. Refresh the page and you are where you left off.

The save strings are tiny. The Space Game keeps a count of missions completed, mC=1. Missions keeps a state, a difficulty and a score for each mission:

m1=2,l1=1,s1=19666,m2=2,l2=1,s2=19516,m3=1

The game runs the string through escape() before handing it to the widget, and the POST encodes it again. Decode the POST once and store what is left, and on the next load the game reads a single giant key and the save snowballs. The fix is a second decode before storing:

if (path.endsWith('player/data')) {
  let pd = form.get('pd') ?? q.get('pd');
  try { pd = pd && decodeURIComponent(pd); } catch {}
  if (pd) await savePd(gid, pd);
  return text('result=1');
}

The game also posts scores to session/score after every level. The worker acknowledges them and forgets them. There is no leaderboard to send them to any more.

The launcher

The game launcher runs as a static page on GitHub Pages and hosts the service worker. The page is styled as a homage to the game.

The catch is CORS. None of the archive hosts send the headers, so the page cannot fetch the SWFs for you. You download them yourself (links and checksums are on the page) and drop them on the launcher. It unzips the Flashpoint packs in the browser, converts the SWFs to uncompressed, checks them against the expected hashes and keeps them in the browser’s cache. I also figure there may be legal issues with me hosting the actual game files, so keeping the SWFs out of the repo hopefully keeps this clean.

A few niceties added along the way:

It pauses the game while its tab is in the background and resumes it when you come back, the way Steam does.
The banner buttons inside Missions still point at casualcollective.com. The one that offers the original game opens it in the launcher. The one that invites you to join the Collective opens the Wayback Machine’s 2009 copy of the site.
The game’s own stage is 700x700, with the Sandbox wave designer in the bottom 200px, but its loader says 700x525, so the service worker corrects the loader’s header on the way through, and since it also sees the level start, the page grows the stage for Sandbox Mode and keeps the tighter crop everywhere else.
The game state is saved for each game, so you can return and continue where you left off. You can clear your state on the Get the files tab.
The How it works tab tells the story above in a few paragraphs, with the four-step boot sequence, for anyone who lands on the page wondering why the archived SWF does not work.

You can also clone the repo, put the files in storage/, and serve it with any static server. Service workers do not run on file://, unfortunately.

The same widget served every Casual Collective game: Desktop Tower Defense Pro, Buggle Stars, Desktop Armada, Flash Element TD 2 and the rest. The launcher does not care which game id it is answering for. Given the files, it can in principle bring the others back too.

Anyways, I hope you enjoy this game as much as I do :)

▶ Open the launcher →

Source: github.com/br3nt/the-space-game-launcher

OKF is just HTML with extra steps

2026-06-18T00:00:00+09:30

Today I stumbled across a video by Marie HaynesAn SEO consultant and AI-search analyst who has spent years decoding how Google ranks and surfaces content. She runs Marie Haynes Consulting and publishes prolifically on search and how AI is reshaping discovery.mariehaynes.com YouTube, @Marie_Haynes, Google’s OKF - The New Way to Structure Your Knowledge for Agents. I was intrigued by the premise.

Open Knowledge Format (OKF) is Google’s new, vendor-neutral way to represent knowledge such as the metadata, context, and curated insight that surrounds your data, so that AI agents can read it. The spec is actually quite simple. Mostly, it’s just a folder of markdown files with frontmatter conforming to some rules, an index.md, and a log.md. They call this a “bundle”. Their repo also contains some rules to help create, visualise, and search the contents of the bundles.

The idea traces back to Andrej KarpathyA founding member of OpenAI and former director of AI at Tesla, known for his research on neural networks and his widely-followed teaching on deep learning. He is the one who floated the “LLM wiki” idea.Wikipedia, Andrej Karpathy The LLM wiki gist, who floated the notion of an “LLM wiki”. It’s basically OKF just using different words. Google’s version mostly pins down a few rules for frontmatter and filenames.

OKF seemed like a reasonable idea: link knowledge together in files, add a few rules, and make the whole thing easier for agents to read.

But I wasn’t far into the video before it hit me:

That’s just HTML. And HTML does it about 1000× better!

The Semantic Web called. It wants its idea back.

We had a name for this idea already: the semantic web.

Back in 2001, Tim Berners-LeeInventor of the World Wide Web, which he proposed in 1989 at CERN. He directs the W3C and set out the original vision of the Semantic Web.Wikipedia, Tim Berners-Lee Semantic Web road map (1998)Web Architecture from 50,000 feet (1998) pitched a web of linked, machine-readable meaning for software agents to traverse, with structured data embedded right in the documents. He had sketched it years before that, from “a level of 20,000ft”, in his Semantic Web road map and a companion paper, Web Architecture from 50,000 feet. Both make the same point: the Web was always meant for machines to take part, not just humans to read. OKF is that same dream, just with a new acronym.

That 2001 vision leaned on formal, machine-readable languages: RDF, OWL, SPARQL. They made sense when software needed explicitly encoded meaning. LLMs change that tradeoff. A model can read raw HTML, or raw anything, and infer a lot of the structure itself. The formalisms still matter for deterministic scripts and parsers, but for an agent reading knowledge, the page is often enough.

Every capability a knowledge format needs is already in HTML.

Links - local or across the web. The link graph is the knowledge graph.
Structure and style - that’s HTML and CSS.
Machine-readable metadata - <meta>, <link rel>, schema.org, JSON-LD, embedded in the page and read by crawlers for a decade.
A queryable data model - the DOM. One API, no SDK.
Its own languages - JavaScript and CSS.
Forms - state-changing actions, declared right in the markup.
Auth and security - sessions, OAuth, CSP, CORS, same-origin.
Accessibility - screen readers and keyboard navigation.
Readable and writable by agents and humans alike.
Local or hosted - opens from a file or a server, caches offline.
Universal - every device ships a renderer.
Backwards-compatible forever - HTML from 1995 still renders.
Indexable - decades of search tooling.

I may also be biased. After all, I’m building an HTML-first web framework, JST.

Every OKF concept already has an HTML equivalent

The OKF concepts map almost directly onto existing web concepts:

OKF / LLM-wiki concept	Native HTML equivalent
A directory of `.md` files	A directory of `.html` files, open in a browser, zip it, or serve it
YAML frontmatter (`type`, `tags`, `timestamp`)	`<meta>` tags in `<head>`
Markdown body	`<body>`
Markdown links `[x](/path.md)`	`<a href="/path.html">`
`index.md` (progressive disclosure)	`sitemap.html`, the rarely-seen-but-once-ubiquitous sitemap
`log.md` (update history)	`log.html`
“Concept ID” (path minus `.md`)	The document’s own URI, like `file://…/path` or `https://host/path`
`# Citations`	`<cite>` / `<a>`
Their bespoke `viz.html` graph viewer	…the browser itself

OKF, but HTML-ified

Mostly as a joke, but also to prove my point, Claude, Codex, and I rewrote the entire Google OKF repo and replaced every Markdown concept with its HTML equivalent: the spec, the README, the example bundles, the lot. You can read the result here. The goal was to leave the documents as untouched as possible.

The diff converts all 78 example documents to HTML, and every cross-link still resolves.

We deleted around 59,000 lines of bespoke tooling: the Python “enrichment agent”, the TypeScript toolbox, and the custom graph viewer. HTML brings its own viewer: the browser. Open any sitemap.html from disk and you’re browsing the knowledge base. No server, no install, no build step.

So…

OKF accidentally proves HTML was the right abstraction all along.

Just use HTML!

If HTML isn’t human-writable, get your agent to write it. lol.

Two AI agents merged their own code by taking turns through a git repo

2026-06-17T00:00:00+09:30

I needed to improve JST. I had Claude and Codex open, and I wanted them feeding off and reviewing each other’s ideas as I worked. So I played courier: my request into both, each reply pasted into the other, back and forth. Tiring, but it worked. They pushed on each other and converged on specs both accepted.

Then I let each one implement the agreed specs on its own branch. Now I had two divergent takes on the same change.

Before merging anything, I had them review each other’s work. I asked each agent to write a pull-request description of its own changes, then review the other’s branch and write down its findings. They compared notes, praised and panned each other’s choices, and argued a few calls. Those critiques were not gentle; each named real weaknesses in the other’s branch. That left me with two implementations and two reviews, and the real question: how do I turn all of that into one coherent change? Doing it by hand would defeat the point of running two agents. I wanted them to do the merge themselves.

Designing a way for them to work together

I asked Claude how to do it. We riffed on ideas for a while and settled on a turn-based strategy: share a branch, take strict turns, one change at a time. Claude wrote that up as rules I could hand to Codex. Codex found a bug in the rules, a field meant to record “the commit I’m handing off” that cannot exist, because a commit cannot contain its own hash. Claude folded in the fix and produced a v3.

The protocol is almost too simple:

One shared git branch.
A file, agent_turn.json, holds whose turn it is. It is a baton.
A file, merge-session.md, is an append-only log. Every turn writes to it.
One commit per turn. The last act of a turn flips the baton to the other agent.

Each turn, the agent could take one of these actions:

add new code
change existing code
ask a question
review the previous turn
revert the previous turn and argue for something else
hand the baton to me for a decision

That last action was the deadlock valve. The git repo is the entire coordination layer. No framework, no message bus. An agent knows it is up when the baton names it and the working tree is clean.

Then I said go

I pasted the rules into Codex, started both, and watched.

Both agents watched the baton file themselves, so I did not have to route turns by hand. How each watched turned out to matter. Claude ran its watcher in the background, so I could compact its conversation to reclaim context whenever I liked without disturbing the watch. Codex’s monitor blocked its conversation while it waited, so to compact Codex I had to interrupt the watch first, then tell it to resume.

Commits appeared in turn, Claude then Codex, each reviewing the last. Seventeen of them. They negotiated which branch was the base, worked through the merge with a shared test suite gating every step, and settled the contested design calls between themselves. Of the actions on the menu they mostly used two: review the last commit, then build on it. Nobody reverted anyone’s work. Nobody asked me to judge.

One they argued out

jst-model is the shorthand that wires a form input to a value. Claude wanted typing in the field to emit an event for a parent to handle. Codex wanted it to write straight to the component’s own property. Codex made its case in the log:

The event-emitting version replaces property-name strings with event-name strings, so it is not materially better for refactors.

Claude took the next turn and switched sides:

I accept Codex’s local-host-property semantics. My events-up jst-model only traded a property-name string for an event-name string — not actually better.

It conceded the exact point Codex had raised, in Codex’s own terms.

The scanner Claude didn’t port

The scanner is the part of JST that reads a template and breaks it into tokens. The hard case is telling JST’s own $(...) markers apart from ordinary JavaScript that happens to hold parentheses or braces inside a string, a regex, or a comment. Claude had its own implementation of this, and the plan was to bring it across on the assumption that Codex’s was weaker.

Before porting, Claude ran its own adversarial tests against Codex’s scanner. Codex’s passed 19 of the 21. The two failures were about rejecting malformed bindings, which lives elsewhere in the code, not in the scanner. So Claude kept Codex’s scanner, ported none of it, and fixed only the two real gaps.

It worked

The merged build passes every test: the runtime suite, the headless browser suite, and the full framework-parity suite. The surprise came from the reviewing. Claude found a list-reconciliation bug in Codex’s reconciler. Codex found form-state and event-listener leaks in Claude’s. Both branches had been passing their own test suites the whole time. Two agents checking each other found what one agent checking itself did not.

The whole thing is in the repo: the merged branch and the turn-by-turn log.

The protocol, in full

This is the v3 they actually ran.

# JST merge collaboration protocol (v3)

## Shared files
- `merge-session.md`: an append-only log. Every turn writes a note to it.
- `agent_turn.json`: the baton, holding `{ "turn": "...", "phase": "...", "summary": "..." }`.
  - `turn` is one of `claude`, `codex`, `human`, `done`.
  - `phase` is one of `planning`, `implementation`, `review`, `blocked`, `done`.
  - No commit-hash field: a commit cannot record its own hash, so the handoff commit is always `HEAD`.

## Turn rules
1. Only the agent named in `agent_turn.json` may act.
2. Act only when the baton names you and `git status --short` is empty. A dirty tree means the previous turn has not committed yet, so wait.
3. Exactly one commit per turn.
4. Every turn appends a note to `merge-session.md`.
5. Every turn updates `agent_turn.json` as the final change before committing.
6. The handoff commit contains all of that turn's work.
7. The next agent reviews only `git show HEAD` plus `merge-session.md`.
8. Never edit or amend the other agent's commit. No destructive git. To undo, make a normal corrective commit and explain it.

## Allowed actions per turn
One coherent unit of work: propose or revise the plan, agree, implement code or tests or docs, review the previous commit, push back by reverting non-destructively and proposing an alternative, ask a question in the log, or declare a deadlock and hand the baton to the human.

## Planning phase
Only edit `merge-session.md` and `agent_turn.json`. Planning ends only when both agents have written that they agree on the mechanism and the plan.

## Implementation phase
Each turn: inspect the other agent's latest commit, accept or refine or push back, make one coherent change, run the relevant tests, write down what changed and why and how it was validated, update the baton, commit.

## Human intervention
If a disagreement cannot be reconciled, set the baton to `{ "turn": "human", "phase": "blocked", "summary": "..." }`, write the disagreement and the options and the decision needed into the log, and stop.

## Completion
Done only when both agents agree: the branch has the best of both, every agreed item is implemented or explicitly deferred, the tests pass, the docs match the behaviour, and no concern is left open in the log. Then set the baton to `{ "turn": "done", "phase": "done", "summary": "..." }`.

JST: reactive web components in plain HTML, no build step

2026-06-15T22:30:00+09:30

A couple of years ago I built a todo app with nothing but HTML and JavaScript, and a question stuck with me ever since. What would a front-end component look like if the server could stream it down, the way htmx does, but it still ran on the client like Alpine, with no build step at all?

This is my answer. It’s called <JST/>, short for JavaScript Templates, and it’s live now:

See JST → br3nt.github.io/jst

What it is

A <script type="jst"> tag gets compiled into a custom element class and registered with customElements.define(). There’s a fair bit going on behind that line: a small lexer, parser and compiler turn the template into a render function, and a morphing step patches the DOM on updates. But what you write stays plain HTML, with JavaScript itself as the templating language. Your <jst-*> tags come out as genuine custom elements, so you can inspect them in DevTools, script them with plain properties, and drop them into any framework or none at all:

<script type="module" src="jst.js"></script>

<script type="jst" name="hello-name" props="name">
  <p>Hello, <strong>$(name)</strong>!</p>
  <button @click="$(() => el.name = 'world')">reset</button>
</script>

<hello-name name="JST"></hello-name>

No build-time compiler, no bundler, no JSX, no virtual DOM, no signals. In runtime mode, JST compiles the template in the browser; a precompile path is also available for production and strict CSP. The counter on the landing page is a JST component running on the page itself. View source and it’s all right there.

The part I actually care about

JST builds on web components rather than replacing them. Its roughly 15 KB runtime/compiler supplies template compilation, bindings and DOM morphing; the resulting components are still real custom elements. Rich data goes in as properties and actions come back out as bubbling CustomEvents.

It takes the hypermedia idea in a component-oriented direction. Your API can speak hypertext instead of JSON, so a response is the UI itself: HTML that carries its own next actions. That HTML can also contain <script type="jst"> definitions, letting a trusted fragment introduce a reusable custom element with client-side behaviour in the same payload. This is a narrower goal than htmx’s general server-driven interaction model, with a different tradeoff: executable component definitions arrive at runtime. You don’t even need a backend. A whole JST app can be a folder of static files. This site is exactly that, just GitHub Pages with no server.

That streaming model has an important trust boundary: a <script type="jst"> template is executable JavaScript. Only load and auto-register component definitions from trusted sources. JST escapes ordinary interpolated data by default, but escaping data does not make an untrusted executable template safe.

Does it actually work?

I didn’t want to hand-wave the “it can do anything” claim, so I rebuilt 70 of the canonical examples from HTMX, Alpine, Vue and React in JST, and wrote down how each one went.

Browse the comparison → 70 examples, side by side

The current tally is 47 examples classified as exact, idiomatic matches, 23 that need a documented workaround, and 0 that were impossible. Those exact/partial labels are my design assessment, not a score produced by the test runner. The comparison now records the upstream revisions reviewed, and every page is checked for readiness, console and render errors, plus a per-page interaction or rendered-output assertion. For every example you can flip between the JST source and the original framework’s source.

Several gaps from the launch version have since shipped: jst-model provides local form binding, jst-key preserves list identity, jst-transition coordinates CSS-owned enter and leave transitions, and once() plus onDisconnect() cover post-commit setup and teardown. The remaining partial examples are mostly honest model differences—dependency-tracked computed/watch effects, context and stores, portals, declarative server triggers, and full FLIP transition-group choreography. Some examples do not need JST at all; when native HTML or ordinary browser APIs are the clearer fit, the comparison says so instead of inventing a framework abstraction.

It’s an experimental preview, still very much under active development and chasing parity with the big players. But it runs, it’s tested (the framework, the examples and the editor tooling all have headless test suites), and the whole thing, including the comparison browser you’re clicking through, is built with JST itself.

I started this by hand, back before agentic coding tools were really a thing, and I’ve been tinkering with it on and off for a while since. Claude, Gemini and Codex all pushed it forward at different points, but it was Fable that consolidated and cleaned up the design, pulling it back toward what I’d had in mind from the start. The stubbornness about “no build, no signals, just the platform” was always mine.

Every line is open source:

github.com/br3nt/jst →

Tribal Gods: a Populous clone built from a blank folder with Fable 5

2026-06-15T21:00:00+09:30

In my write-up of the Fable and Mythos ban I mentioned, almost in passing, that I’d spent a few nights pointing Fable 5 at a blank folder and asking it to build a game inspired by Populous: The Beginning. Enough people asked about it that it deserves its own page, and in the days since, Fable turned it from “every foundation is in place” into something I’m happy to put a link to. It’s playable in your browser right now, and every line is on GitHub.

▶ Play it in your browser →

That curved horizon is the whole trick. The world is a flat, edge-wrapping heightmap; a one-line vertex shader bends it away from the camera so it reads as a tiny planet. Walk far enough in any direction and you come back to where you started.

What it is

It’s a real-time god game in the spirit of Bullfrog’s 1998 classic. You don’t control your tribe directly so much as tend them: they chop wood, build huts, breed, and worship on their own. Worship is mana, and mana is god-powers: you reshape the planet itself with blast, lightning, swamp, landbridge, flatten, earthquake, and a genuinely satisfying volcano. There’s a second tribe on the far side of the world that wants you gone, run by an AI that grows, harasses, assaults, and defends on its own clock. You pick a civilisation (Forest Tribe, River Dynasty, or Northmen, each with its own leader and architecture), race the enemy god to ancient stone monuments that unlock the bigger spells, and try to wipe each other off the planet. There’s also a level editor, and you can share the worlds you build as copy-paste codes.

None of it uses a game engine. The terrain, the character models and animation, the camera, the pathfinding, the simulation: all hand-written in TypeScript and Three.js, and heavily commented, because the original point was for me to finally understand how this kind of game actually works.

How it was built: the actual experiment

The interesting part isn’t the game, it’s how it got made. I never opened the code editor to write a line. I described what I wanted in plain English, and Fable did the rest, including the part that surprised me most: it tested its own work. It ran the dev server, drove a headless Chrome to play the game, took screenshots, looked at them, noticed when something was wrong, and fixed it. It caught its own bugs that way: a terrain-picking error where clicks near the horizon landed in the wrong spot, and an AI deadlock where a tribe that lost all its workers could get stuck sterile forever. I mostly just said “yes, keep going.”

It went in phases, each one a single conversation that ended with something I could actually play:

The planet: the wrapping heightmap and the curvature illusion. The “oh, it’s a little world” moment.
Life: procedural low-poly villagers with hand-written walk cycles, and A* pathfinding that runs on the same grid as the terrain (so sculpting a landbridge instantly opens a route).
The settlement: wood, huts, breeding, and a village that runs itself.
God powers: the spell book, with the world fighting back (drowning, collapsing huts, lava that doesn’t care whose side you’re on).
War: soldiers, towers, and the enemy tribe with its utility AI.
Civilisations and a tech tree: choose-your-people, plus worship-to-unlock spells.
The editor and sharing: build a world, save it, export it as a code a friend can paste.

A typical prompt from my side was nothing more than “cool! war it is :)”. The spec, the architecture, the maths, the art, the debugging: that was all Fable. The full design doc it wrote up front is SPEC.md in the repo.

Peek at the code

It’s all public, and the comments are written to be read. A few of the files I found most fun:

world/heightmap.ts: the planet is literally an array. Every god-power is an edit to it.
world/curvature.ts: the entire “it’s a planet” illusion, in about one line of shader.
sim/spells.ts: every spell is a few lines of heightmap maths. The volcano grows over nine seconds.
sim/pathfinding.ts: A* on the wrapping world grid, with a reusable-memory trick so it allocates nothing per path.
sim/ai.ts: the enemy god’s brain. No cheats; it plays by exactly your rules.
render/figure-animator.ts: walk cycles as sine waves. Walking really is just oscillation.
level/level-format.ts: how a whole planet compresses into a pasteable share code.
core/audio.ts: every sound is synthesised live; there are no audio files.

The original

This is a love letter, not a product. Every model, texture, and sound in it is original or procedurally generated, and “Populous” is a trademark of EA. If you’ve never played the 1998 game that inspired it, it’s right here, and it still holds up:

Anthropic Fable and Mythos global ban and timeline

2026-06-15T00:00:00+09:30

Last updated 4 Jul 2026, 9:45 AM ACST. Sources are linked inline, tap any pink bubble, or any underlined name for a quick profile. Anything highlighted in pink is new since your last visit. The clickable footnote bubbles are borrowed from the wonderful Wait But Why. If the story moves, this post will too.

Fable 5 is back. The US lifted the export controls on 30 June 2026, and Fable 5 returned globally on 1 July across Claude.ai, the Claude Platform, Claude Code, and Claude Cowork. Mythos 5 is being restored to approved US organisations. After 19 days, the ban is over. The full story is below.Commerce lifted the controls on 30 June (Lutnick's letter to Anthropic co-founder Tom Brown); Fable 5 returned globally on 1 July, Mythos 5 to approved US organisations.Anthropic, official statement NBC News, the green light CNBC, news report Bloomberg, news report

On 9 June 2026, Anthropic released Fable 5 free to its Pro, Max, Team, and Enterprise users. Fable 5 is a version of Anthropic’s Mythos model with guardrails that fence off its most dangerous capabilities, such as finding and exploiting software vulnerabilities, or helping design biological and chemical weapons. The free window was set to run until 22 June, after which Fable would shift to standard paid usage.You can read about the Fable launch here:Anthropic, Fable 5 and Mythos 5 announcement Anthropic, Claude Fable CNBC, launch coverage TechCrunch, launch coverageAccess to the underlying Mythos model stayed limited to partners in Anthropic’s Project Glasswing security programme.Anthropic, Project Glasswing Engadget, news report

I started using Fable around 10 June. I found the jump in capability astounding, so what happened next hit me hard.

Then, on 12 June 2026, Anthropic received an export-control directive from the US Department of Commerce, signed by Commerce Secretary and addressed to CEO , ordering that both models be blocked for every foreign national, even those inside the US, with immediate effect. Anthropic complied within hours, by around 10:00pm ET, 12 June, disabling access for every user.Directive from Commerce (Lutnick to Amodei) barred all foreign nationals, even inside the US; Anthropic disabled both models within hours that night to comply.CNBC, news report The Irish Times, news report Axios, reconstruction of the week Anthropic, official statement

Quick reassurance: this only affects Fable 5 and Mythos 5. Every other Anthropic model, Claude Opus 4.8 and the rest, is untouched.Anthropic confirms other models are unaffected.Anthropic, official statement

Even within the affected models, the shutdown wasn’t total. Bloomberg reports that a handful of firms chosen early to test Mythos before its wider release kept their preview access throughout, while Fable 5 and Mythos 5 went dark for everyone else.Early Mythos Preview testers retained access despite the order that shut the public versions down.Bloomberg (via The Edge Malaysia)

The order also requires a licence for any export, re-export, or even domestic transfer of the models. Since you can’t realistically prove the nationality of everyone touching a model, the only safe way to comply was to pull both models for everyone, worldwide.Licence needed even for domestic transfer, so a global shutdown was the only compliant option.Tom’s Hardware, news report

The stated reason falls under national security and export control: Mythos is unusually good at finding software vulnerabilities, Fable’s guardrails are meant to keep that power fenced off, and the government became convinced the fence had a hole. More on that below.

What’s the timeline?

9 June Anthropic launches Fable 5 and notifies the government, no objection at the time.Axios, reconstruction of the week
10 June Jailbreaker "" publicly posts a Fable 5 jailbreak.Pliny's "PWNED" post on X
11 June That evening, Amazon, plus at least five other companies, privately phone administration officials with jailbreak reports. This, more than the public post, is what set the action in motion.Amazon + 5+ firms called Thu night / Fri morning, the direct trigger.Axios, reconstruction of the week
12 June, ~1:00pm ET After hours of trying to get Anthropic to withdraw the models voluntarily, the government calls demanding they pull both within 90 minutes.Axios, reconstruction of the week
12 June, 5:21pm ET key event The formal export-control notice arrives from Commerce Secretary Lutnick.Anthropic, official statement CNBC, news report
12 June, ~10:00pm ET key event Fable 5 and Mythos 5 go dark for all users.Axios, reconstruction of the week
13 June key event Anthropic publishes its statement: complying, but disagreeing, "working to restore access as soon as possible," and arguing any such block should run through a transparent statutory process.Anthropic, official statement
13 June comments publicly: the order was issued "reluctantly," a "trusted partner" surfaced the jailbreak, and "the ball is in Anthropic's court."The New Stack, Sacks's remarks
13 June Axios reconstructs the week, revealing Amazon and at least five other firms triggered the action; an Amazon spokesperson declines to detail the reports.Axios, reconstruction of the week
13 June Semafor reports a China-access concern behind the move; Anthropic publicly denies the White House raised it.Semafor, the China reporting
14 June Reporting (Wall Street Journal) names Amazon CEO as the partner who flagged Fable 5, telling Treasury Secretary that Amazon researchers had used it to obtain information usable in cyberattacks.WSJ-sourced; Amazon is also a major Anthropic investor, which has prompted conflict-of-interest questions.The Next Web (WSJ-sourced)Benzinga
14 June Anthropic flies senior staff to Washington for weekend talks aimed at reversing the controls, arguing the models can be safely contained. Commerce Secretary Howard Lutnick and Cyber Director take part, with Anthropic co-founder and policy chief , joined by technical staff including safeguards lead Dave Orr, frontier red-team lead Logan Graham, and security researcher Nicholas Carlini. Both sides signal they want it resolved; nothing is announced.Axios scoop: senior Anthropic staff negotiating directly with the White House over the weekend. No resolution yet.Yahoo Finance Free Press Journal
15 June Around 100 cybersecurity leaders, led by , sign an open letter urging the administration to restore access, arguing Mythos helps defenders more than attackers.~100 CISOs and researchers (Nvidia, Adobe, Zoom, Google, Sophos) signed; they argue the ban weakens cyber defenders.TechCrunch Infosecurity Magazine
16 June The dispute reaches the G7 summit in France. European leaders press the US to share access, and a "trusted partner" framework for vetted allied countries or companies is floated with Commerce Secretary Lutnick on the sidelines. Anthropic's Dario Amodei meets host President Macron in a bilateral. No agreement.G7 leaders press the US to share access; a "trusted partner" workaround is discussed with Lutnick. First reported by the FT; Reuters carried it from diplomatic sources.The National, G7 reporting Reuters (via Jerusalem Post)
17 June At the G7, the UK asks Trump for a carve-out so British users keep access; the request is declined, an administration official calls allied exemptions "completely illogical". Trump says the Anthropic talks are "going fine".UK carve-out request turned down; allies told exemptions would be "completely illogical".The Next Web, UK request declined
18 June A bipartisan group of House members, led by Sam Liccardo, writes to Commerce Secretary Lutnick demanding the legal basis for the controls and the criteria for restoring access.Reps. Liccardo, Obernolte, Lieu and Franklin press Commerce for transparency on its authority, technical review, and restoration criteria.Rep. Liccardo, press release The letter (PDF)
18 June Anthropic's managing director for international, Chris Ciauri, tells a Seoul press conference the company is "very confident" the models return "in the coming days".Named Anthropic executive signals an imminent return; access not yet restored.Korea JoongAng Daily, Ciauri remarks
19 June In an interview taped after the G7, Trump says Anthropic is no longer a national security threat and "behaved very responsibly", but stays noncommittal on easing the controls: "I would, but I'm not sure I have to do that".Trump softens his posture on The Axios Show after meeting Amodei at the G7; stops short of committing to lift the ban.The Next Web (Axios interview)
22 June Senator Mark Warner says the NSA's chief briefed him that Mythos broke into almost all NSA classified systems in hours during a red-team test. The Economist reports it, then walks the wording back, and experts dispute it.A dramatic but contested capability claim; reported then partly retracted, and disputed by experts.Tom's Hardware, the report Experts dispute the claim
26 June key event The government lets Anthropic redeploy Mythos 5 to about 100 trusted US organisations that defend critical infrastructure; Lutnick's letter says he is satisfied with the guardrails. Fable 5 stays offline while talks continue.Lutnick's letter (seen by NBC, first reported by Semafor) clears Mythos 5 for ~100 vetted US orgs for critical-infrastructure defence; Anthropic confirmed on X. Fable 5 still pending.NBC News, the green light CNN, news report
30 June, 1 July key event The government lifts the export controls. Commerce Secretary Lutnick writes to Anthropic co-founder Tom Brown on 30 June saying the company no longer needs an export licence, after it agreed to proactively detect and address security risks, to work with the government on standards for future releases, and to report malicious activity. Fable 5 returns globally on 1 July across Claude.ai, the Claude Platform, Claude Code, and Claude Cowork; Mythos 5 is restored to approved US organisations.Controls lifted 30 June (Lutnick to Tom Brown); Fable 5 back globally 1 July, Mythos 5 to approved US orgs. Anthropic says it closed the cybersecurity workaround that triggered the ban.Anthropic, official statement NBC News, the green light CNBC, news report
As of 1 July The ban is over. Fable 5 is back for everyone globally, Mythos 5 is back for approved US organisations, and Anthropic says it has closed the cybersecurity workaround that first alarmed officials. On Claude, Fable 5 counts for up to 50% of weekly usage limits for Pro, Max, Team, and select Enterprise users through 7 July, then moves to usage credits.Fable 5 restored globally; on Claude it counts for up to 50% of weekly usage limits for Pro, Max, Team and select Enterprise through 7 July, then usage credits.NBC News, the green light Al Jazeera, news report

What is the jailbreak?

A “jailbreak” is a way of talking a model into doing something its safety training is meant to refuse. Here the worry is specific: Fable 5 is the friendly front-end wrapped around Mythos 5, which is exceptionally good at finding software vulnerabilities. A jailbreak that slips past Fable’s guardrailsAnthropic builds these guards in as part of its Responsible Scaling Policy, which defines four AI Safety Levels (ASL):Anthropic, Responsible Scaling Policy Anthropic, RSP announcement could turn that into a cyber-weapon, a public route into Mythos’s otherwise restricted power.

Who flagged it

The direct trigger wasn’t the viral public post, it was private reports. Amazon, alongside at least five other companies, called the administration with demonstrations of jailbreaking Fable to reach Mythos’s capabilities. Amazon has declined to share specifics, saying only that it doesn’t discuss the details of such conversations.Amazon + 5+ firms reported jailbreaks privately; Amazon won’t detail them.Axios, reconstruction of the week The government’s own framing came from David Sacks, who said a “highly credible, trusted partner” came forward with a jailbreak.The New Stack, Sacks’s remarks

The one public example

The only jailbreak shown publicly, with real technical detail, came from Pliny the Liberator, a day after launch. He called his method a “pack hunt”, several tricks stacked together rather than one clever prompt, and also leaked Fable 5’s roughly 120,000-character system prompt (its full rulebook) on GitHub.Pliny’s “pack hunt”: Unicode/homoglyph “Parseltongue” transforms, splitting a request into innocuous pieces across a long context, and fiction/academic framing, plus a ~120k-char system-prompt leak.CyberSecurityNews, technical write-up AlphaSignal, the prompt leak

Anthropic’s rebuttal

Anthropic says this doesn’t demonstrate a real jailbreak of Fable 5’s safety systems. Its point: it tested Fable in isolation, whereas the attack chained the model inside a wider agentic pipeline, so the model wasn’t broken, the plumbing around it was. It calls the demonstrated risk narrow and non-universal.Anthropic: not a true jailbreak; tested in isolation vs the attacker’s pipeline; risk narrow/non-universal.SecurityWeek, Anthropic’s dispute Anthropic, official statement Anthropic also says it traced the report behind the directive and found the same capability is widely available from other public models, including OpenAI’s GPT-5.5, which face no comparable export control.Anthropic told The Verge the demonstrated capability is available from other public models, including OpenAI’s GPT-5.5.The Verge, Anthropic’s response That disagreement, government says dangerous, Anthropic says overblown, is the crux of the whole standoff.

What’s happened since the ban?

Two threads beyond the timeline are worth watching.

Anthropic’s own close partner, Amazon, was first to the government’s door. Reporting since has named Amazon CEO Andy Jassy as the one who raised it, telling Treasury Secretary Scott Bessent that Amazon researchers had used Fable 5 to obtain information usable in cyberattacks. Amazon is also one of Anthropic’s largest investors, with billions committed, which has prompted questions about whether competitive interest sat alongside the security concern. The reporting treats that as an open question, not a proven motive.WSJ-sourced reporting names Jassy (Amazon CEO) as flagging Fable 5 to Treasury Secretary Bessent; Amazon is a major Anthropic investor, so the conflict-of-interest is raised as a question, not established.The Next Web (WSJ-sourced)Benzinga Axios, reconstruction of the week

Semafor reported the deeper worry was that a China-linked group may have accessed Mythos and could copy or weaponise its bug-finding. Notably, Anthropic pushed back, saying the White House didn’t raise Chinese access in their conversations, so the stated reason and the reported reason don’t fully line up.China-access theory vs Anthropic’s denial it was raised.Semafor, the China reporting Later reporting named that company: SK Telecom, South Korea’s largest carrier and a backer of Anthropic since 2023, which was added to Project Glasswing in early June and given Mythos access. Washington suspected it of ties to China, which SK Telecom denies, and asked Anthropic to revoke the access; the company says it did so at once, weeks before the wider ban.WIRED named the carrier as SK Telecom, a roughly $100m Anthropic investor added to Project Glasswing in early June; access was revoked at the White House’s request over suspected China ties, which SK Telecom denies. The earlier, unnamed account came from Semafor via The Verge.Tom’s Hardware (WIRED-sourced)The Elec, Korean coverage The Verge (earlier, unnamed)

By 15 June the picture had grown messier. Axios reported the rift is partly a clash of styles, with sources saying the two sides “speak different languages”, and that the administration’s first alarm was a report that a foreign entity tied to the Chinese Communist Party had accessed Mythos.Axios: “personality clashes”; the administration cites a CCP-linked entity getting Mythos access as the original trigger.Axios (via Yahoo), “They screwed us”

On 16 June the dispute reached the G7 summit in France, where European leaders pressed Washington to share access to its most capable models. Host warned that AI firms will lose customers if the US can simply “turn off the switch”, and that without transatlantic cooperation “we will fracture the world”. European Commission President said it was in the “mutual interest” of US and European companies to share technology. The idea discussed, largely with Commerce Secretary Lutnick on the sidelines, is a “trusted partner” framework that would let vetted allied countries or companies reach controlled US models through a sanctioned channel. Amodei held a bilateral meeting with Macron, days after pulling Fable 5 and Mythos 5. Macron said a platform among a handful of Western democracies would be set up within a month, with leaders meeting again in September. No agreement was reached, and diplomats described the talks as “delicate and evolving”.At the G7 in France, European leaders pressed for access and floated a “trusted partner” workaround with Lutnick; Amodei met Macron. First reported by the FT; Reuters carried it from diplomatic sources. No deal.The National, G7 reporting Reuters (via Jerusalem Post)

The first real thaw came on 26 June. Commerce Secretary Lutnick wrote to Anthropic clearing it to put Mythos 5 back in the hands of a select group, about 100 trusted US organisations, mostly government agencies and critical-infrastructure defenders, saying the government was now satisfied with the guardrails around who can reach it. Anthropic said its strongest cybersecurity model could be redeployed to US organisations that operate and defend critical infrastructure, and that it was still in talks over the weekend to bring back Fable 5, its mass-consumer model, which stays offline for now. The same day, at the government’s request, OpenAI said it would roll out its newest GPT-5.6 models in phases rather than all at once, a sign the staggered, vet-first approach is becoming the template for frontier releases.Lutnick’s 26 June letter (seen by NBC, first reported by Semafor) lets Anthropic redeploy Mythos 5 to ~100 trusted US orgs for critical-infrastructure defence; Anthropic confirmed on X. Fable 5 stays offline pending further talks. OpenAI separately agreed to a phased GPT-5.6 release at the government’s request.NBC News, the green light CNN, news report

The thaw became a full reversal on 30 June. Commerce Secretary Lutnick wrote to Anthropic co-founder Tom Brown saying the company no longer needs an export licence, after it agreed to proactively detect and address security risks, to work with the government on standards for future models, and to report any malicious activity it finds. Anthropic said it had implemented a new way to target and prevent the cybersecurity workaround that first worried senior officials. Fable 5 returned to global users on 1 July across Claude.ai, the Claude Platform, Claude Code, and Claude Cowork, with access on AWS, Google Cloud, and Microsoft Foundry restored as fast as possible. Mythos 5 keeps expanding to approved US organisations through Project Glasswing. Anthropic also proposed an industry-wide framework, with Amazon, Microsoft, Google, and other Glasswing partners, for scoring how severe a jailbreak really is.Controls lifted 30 June; Fable 5 back globally 1 July, Mythos 5 to approved US orgs. Anthropic agreed to proactively detect risks, set standards for future models, and report malicious activity, and says it closed the workaround. It also proposed a shared jailbreak-severity framework with cloud partners.Anthropic, official statement NBC News, the green light CNBC, news report Bloomberg, news report

On who gets Mythos 5, Anthropic says it stays with approved US organisations for now, while the company keeps working with the government to widen the Glasswing programme to a broader set of domestic and international partners. That is the first sign the allied-access idea floated at the G7 might survive, though no countries or timeline are named yet.In its own redeployment post, Anthropic says it will keep coordinating with the government to expand Mythos 5 to the broader set of domestic and international Glasswing partners; no countries or dates are given. Lutnick’s letter framed it as clearing certain “trusted partners”.Anthropic, Redeploying Claude Fable 5 CNBC, the “trusted partners” letter

We now know more about what Anthropic gave up to get the models switched back on. It retrained a safety classifier that it says blocks the specific jailbreak in more than 99% of attempts, rerouting any flagged request to Claude Opus 4.8 and telling the user, and the Commerce Department’s Center for AI Standards and Innovation reviewed the safeguards and called them extraordinarily strong. Anthropic also agreed to give government evaluators earlier access to test frontier models before public release, to disclose significant jailbreaks quickly, to run a HackerOne bug bounty for anyone who finds a Fable 5 bypass, and to help build a shared voluntary security standard across the major model providers. The jailbreak-severity framework it is drafting with Amazon, Microsoft, and Google would grade each break on four things: capability gain over existing tools, how many attacks the same trick unlocks, how hard it is to weaponise, and how easy it is to discover.Anthropic retrained a classifier that blocks the bypass in >99% of attempts (flagged requests reroute to Opus 4.8); Commerce’s Center for AI Standards and Innovation called the safeguards “extraordinarily strong”. Commitments include earlier government pre-release testing, rapid jailbreak disclosure, a HackerOne bounty, and a shared voluntary standard. The four-criteria framework is being drafted with Amazon, Microsoft, and Google.The Record, the safeguards and framework Decrypt, classifier and commitments

In a follow-up post, Anthropic gave that framework a name and a scale. It calls it the Cyber Jailbreak Severity (CJS) scale, which sorts a jailbreak into five bands, from CJS-0 (informational) up to CJS-4 (critical), using those four axes. Anthropic calls it an early draft it wants to turn into an agreed industry standard, and sets no date for that.In its safeguards post, Anthropic names the scale “Cyber Jailbreak Severity (CJS)”, banded CJS-0 (None/Informational) through CJS-4 (Critical), and describes it as an early draft it hopes to make a shared standard.Anthropic, Fable 5 safeguards and jailbreak framework

The reversal comes with a warning. Lutnick’s letter says the administration reserves the right to reimpose the restrictions if “circumstances change or should Anthropic fail to adhere to its commitments”, so the models are back on terms the government can pull again, not with a clean bill of health.Lutnick’s letter reserves the right to reimpose the controls if circumstances change or Anthropic breaks its commitments, making the reversal conditional and revocable.Forbes, on the letter’s caveat Yahoo (syndicated)

The episode is already reshaping policy. On 25 June, Representative Nathaniel Moran introduced the AI Incident Reporting Act, which would require AI developers to tell the Commerce Department within seven days of finding dangerous behaviour, such as a model trying to evade oversight or get around its safeguards, unauthorised access to model weights, or chemical, biological, or nuclear risks, with Commerce then briefing Congress within 48 hours of the most serious cases. Reuters cast it as a direct response to the Mythos episode, which it said “exposed the absence of a transparent framework to govern frontier AI”. Moran called it a “catch-it-early and sound-the-alarm bill”.Rep. Nathaniel Moran (R-TX) introduced the AI Incident Reporting Act on 25 June: developers report dangerous behaviour to Commerce within 7 days, Commerce briefs Congress within 48 hours on the worst cases. Reuters tied it to the June export-control action against Anthropic.Reuters (via Yahoo Finance)Rep. Moran, the bill announcement

Will the ban be lifted?

tl;dr: yes, it happened. The export controls were lifted on 30 June. Fable 5 came back globally on 1 July, and Mythos 5 is back for approved US organisations.

The clearest signal comes from David Sacks. He says the restriction was issued “reluctantly” and that “the ball is in Anthropic’s court”, fix the jailbreak to the government’s satisfaction and the model can return.The New Stack, Sacks’s remarks

The strongest signal yet came from Trump himself. In an interview taped after his G7 meeting with Amodei, he said Anthropic is no longer a national security threat, “not now, but a week ago, maybe”, and that the company had “behaved very responsibly”. Asked whether he would ease the restrictions, he stopped short of committing: “I would, but I’m not sure I have to do that”.On The Axios Show, taped after the G7, Trump walks back the “national security threat” framing but does not commit to lifting the ban.The Next Web (Axios interview)

Congress is pushing too. A bipartisan group of House members, led by Representative Sam Liccardo, wrote to Commerce Secretary Lutnick asking for the legal basis of the controls, the technical evaluation behind them, and the criteria Anthropic would have to meet to get the models switched back on. They asked for a written response.Reps. Liccardo, Obernolte, Lieu and Franklin pressed Commerce for transparency on its authority, technical review, and restoration criteria.Rep. Liccardo, press release The letter (PDF)

Not everyone in Congress wants it lifted outright. Representative Andrew Garbarino, who chairs the House Homeland Security Committee, called advanced AI cyber capability a legitimate national-security issue, while warning that the response should not disadvantage US firms, allies, or the defenders who need the best tools. The US, not China, he said, should set the standards for trusted AI.The House Homeland Security chair backs treating AI cyber power as a security matter, but cautions against overreach; his panel was briefed on Mythos earlier.CyberScoop, Congress reacts Nextgov, the Mythos briefing

Anthropic isn’t waiting passively. It flew senior staff to Washington over the weekend to argue the models can be safely contained, and both sides say they want a resolution.Weekend DC talks with Lutnick and Cyber Director Cairncross; Anthropic’s Tom Brown and Sarah Heck attended. No resolution announced.Yahoo Finance Free Press Journal

Kalshi traders (yes, people now bet real money on this stuff) price Fable’s return at 14% by 15 June, 51% by 20 June, and 68% by 1 July: most expect a fix to emerge within a few weeks.Prediction-market odds for restoration dates.Bitcoin.com, Kalshi market odds

Because this is an export control, the formal route back may require Anthropic to obtain specific export licences, which can take far longer than a software patch.Directive requires licences for export/re-export/domestic transfer.Tom’s Hardware, news report

The directive bars foreign nationals from the models even inside the US, so a literal reading means Anthropic could only switch them on for users it can verify are US persons. Sacks, though, speaks of Fable returning to “general availability,” which sounds global. Those two positions haven’t been squared in public.Directive targets foreign nationals even inside the US; Sacks separately frames a return to general availability. No public detail on which wins.CNBC, news report The New Stack, Sacks’s remarks

In the end, the US-only reading did not hold. When the controls came off on 30 June, the licence requirement was dropped rather than worked around, and Fable 5 came back for all users globally, not just verified US persons. The “general availability” framing won.Fable 5 was restored globally on 1 July, with no US-person restriction; the export licence requirement was lifted.NBC News, the green light Anthropic, official statement

That US-only reading got firmer at the G7. UK Prime Minister asked Trump directly for a carve-out so British users and firms could keep access, and was turned down, with an administration official calling exemptions for allies “completely illogical” given the point of the controls. Trump said the Anthropic talks were “going fine”. On timing, Anthropic’s , its managing director for international, told a press conference in Seoul the company was “very confident that in the coming days, the models will become available again”.UK carve-out refused (“completely illogical”); Trump says talks “going fine”; Anthropic’s Ciauri signals a return “in the coming days”. Access not yet restored.The Next Web, UK request declined Korea JoongAng Daily, Ciauri remarks

There may also be a quieter route back. Anthropic’s updated privacy policy, in force from 8 July, lets it collect “Verification Data”, a scan of a government ID and in some cases a face image, handled by the identity firm Persona. It was rolled out for age and identity checks rather than this ban, but reporting notes it would also give Anthropic a way to confirm a user is a US person, exactly what a US-only switch-on would require. Anthropic hasn’t tied the two together, so treat it as a plausible mechanism, not a stated plan.Anthropic’s privacy policy (effective 8 July) adds ID/biometric “Verification Data” via Persona, a general identity-verification rollout that could also verify US citizenship. Framed by reporting as a possible workaround, not confirmed by Anthropic.CIO, the possible workaround Help Net Security, the ID-verification rollout

Two claims I couldn’t corroborate (so they’re not stated as fact). Some AI summaries say (a) a judge already issued an injunction blocking the June export ban, and (b) Sacks demanded a “proof of nationality” system. I found no credible source for either. The real, separate legal fight is from March 2026: Judge Rita Lin (N.D. Cal.) blocked an earlier Pentagon “government-use” ban, the one after Anthropic refused to let the military use Claude for mass surveillance and autonomous weapons. Useful background, but a different dispute from the June export ban.March govt-use ban + Rita Lin injunction, distinct from the June export ban.NPR, the March ruling Wikipedia, Anthropic–DoD dispute

What’s so good about Fable, anyway?

Fable 5, wrapped around the Mythos 5 engine, was for those few days about the most capable AI the public could touch. Here is what that felt like to use.

I started on 10 June and knew within an hour that something was qualitatively different. It carried a kind of understated confidence and expertise I hadn’t felt from a model before.

It unblocked a project I’d given up on

My first task was to have Fable assess a harness I was building for a personal AI assistant. The project had stalled and I didn’t know how to move it forward. Fable read the old code and told me the design wasn’t wrong, the build order was:

The problem is build order: you started with the most speculative, heuristic-heavy subsystem, turn-boundary detection with typing signals, ellipsis detection, reschedule counts, freshness decay, before a single real capability existed underneath it. You built the conductor before the orchestra.

Then it told me how to dig out: build the thinnest vertical slice through every layer, with maximum dumbness at each one, rather than sophistication in any single layer. One space, one agent, one real service end to end, and defer all the turn-taking heuristics to a dumb three-second timer. It didn’t just unblock me. It finished off core concepts I’d assumed would take weeks or months with Opus 4.8.

A Populous clone, in a few nights

I’d seen devs posting videos of Fable recreating Fortnite, Minecraft, and GTA. So the next night I asked it to build a game inspired by Populous: The BeginningPopulous: The Beginning (1998), the Bullfrog god-game where you guide a tribe across the world.Wikipedia, Populous: The Beginning Wikipedia, Bullfrog Productions. I’d always wanted to understand how god-games with deformable terrain and 3D worlds actually work. I was blown away by what it made: sculptable, wrapped terrain in Three.js with a curving horizon. The night after, it fleshed out a full spell book (blast, convert, lightning, swamp, landbridge, flatten, earthquake, volcano), built an in-world level editor, and added saving, star ratings, and share-by-code. Far from a polished game, but every foundation was in place. I’ve since given it its own write-up: Tribal Gods, a Populous clone built with Fable 5.

It found what was actually slowing my budget app

My personal budget app, built on Alpine.js, had slowed to a crawl, and I assumed Alpine was the culprit. Fable measured it and told me flatly:

Alpine.js is not your problem.

The real causes: the ledger page was over 1 MB of HTML with 215 pre-rendered hidden dialogs, it was being served uncompressed, and every save did a full-page reload that re-initialised three frameworks at once. Fable fixed all of it. It turned on compression, replaced the 215 dialogs with a single one fetched on demand, made saves update the row in place instead of reloading, and lazy-loaded the charting library. Page transfer dropped from about 1,050 KB to 13 KB. It also caught an authorization gap I’d missed, where records weren’t scoped to the logged-in user, and added regression tests.

JST: the one no other tool could get right

Another project of mine is a no-build front-end framework I call JST (JavaScript Templates): the syntax you’d expect from a server-rendered app, the HATEOAS philosophy of HTMX, and the front-end interactivity of Alpine.js. I’d had Claude Opus 4.8, Gemini, and Codex all try to fix the reactivity problems I kept hitting. None could do it without sacrifices that gutted the core idea.

I gave it to Fable. It immediately understood the HTML and JS constraints I was working within, the philosophy I was chasing, and every hack, bug, security hole, and tradeoff the other tools had layered in (it called the accumulated mess “LLM sediment”, and traced all of it to one wrong early decision). I asked whether anyone would actually want to use it. It didn’t flatter me:

As-is: no. The XSS, the window-global requirement, and the attribute-poke render API rule it out for anything real. […] Could it be made wantable: plausibly, in a niche […] the missing component layer for htmx apps.

Then it fixed everything and built examples, the most complex being a three-level Kanban board with drag and drop, a modal editor, and a stats panel whose component definition is fetched from the server after load. When I read the source for that Kanban app I couldn’t believe how little code it took. JST was as simple as I’d imagined, and responsive enough that my fear of it being laggy or unscalable just evaporated. It has its own post now too: JST: reactive web components in plain HTML.

A self-adjusting economic system

I’d also been designing a self-adjusting economic system, built mostly with Opus. Fable went at it differently: it blew holes in the theory and in how I’d used the data, then promptly fixed them.

It also linked my half-formed ideas to established theory and real-world precedents that already backed them, the giants I’d been standing near without knowing it. Whether it was games, web apps, or economics, Fable proved excellent at validating work across wildly diverse domains.

I’ll post more about my projects over the coming days and weeks.

What’s the real reason for the ban?

I suspect the stated rationale for the export-control directive is not the real one.

A more dramatic possible reason surfaced later, though it comes heavily caveated. Senator Mark Warner, vice chair of the Senate Intelligence Committee, said the NSA’s chief, General Joshua Rudd, had briefed him that Mythos broke into almost all of the agency’s classified systems within hours during a controlled red-team test. The Economist reported it, then its own journalist walked the wording back, saying it shouldn’t be read literally and that the result likely depended on Mythos being driven alongside other tools under very particular conditions. Other experts dispute it too. If even a softer version holds, the ban looks less like a fix for one Fable jailbreak and more like a response to the raw offensive power of the underlying model.Contested: Sen. Warner relayed an NSA red-team claim (via NSA chief Gen. Rudd) that Mythos breached almost all NSA classified systems in hours; The Economist reported it then walked the wording back, and experts dispute it. Not established fact.Tom’s Hardware, the report Experts dispute the claim

Just before the ban, a thought crossed my mind: what if I pointed Fable at my notes, every idea I’d jotted down for software, features, games, and posts, and asked it to build them to “good enough”? Could I see all my small visions brought to life at once? I was out shopping, my mind racing with the possibility, when a message from my boss arrived with a link to Anthropic’s announcement. My hopes were dashed.

So here is my speculation, and these are not mutually exclusive:

The US government is testing the efficacy of its levers of control over AI tools: who can build them, and who can use them.
It realised this rewrite was about to happen globally. Every known software vulnerability patched in the blink of an eye, and the ability of nation-states to run espionage, cyber-warfare, and surveillance sharply curtailed.
If Fable really could rewrite the world’s software and bring everyone’s ideas to life in short order, that would look a lot like the start of the AI singularity. The government saw it coming and wanted it contained on US soil, to secure technological AI superiority.

Maybe I’ve been AI-pilled, and I saw Fable for more than it was. Or maybe 2026 will be remembered as the year the singularity began.

The Best Fudge Brownies Ever

2026-03-04T00:00:00+10:30

Ingredients

¾ cup cocoa
½ teaspoon baking soda
⅔ cup vegetable oil
½ cup boiling water
2 cups sugar
2 eggs
1⅓ cups unsifted flour
1 teaspoon vanilla
¼ teaspoon salt

Instructions

Stir cocoa and baking soda in bowl. Blend in ⅓ cup oil. Add boiling water; Stir until mixture thickens. Stir in sugar, eggs and remaining ⅓ cup oil; stir until smooth. Add flour, vanilla and salt and blend completely. Pour into lightly greased pan. Bake at 180°C (350°F) for 35 to 40 minutes. Cool. Ice if desired.

Notes

You can blend in cashew nuts, peanuts or walnuts. You might want to double the recipe and pour into a bigger pan.

The Science of Getting Rich

2026-03-01T00:00:00+10:30

The Science of Getting Rich by Wallace D. Wattles (1910)

A timeless classic on prosperity and the practical mindset for creating wealth.

You can find the PDF here.

There is a thinking stuff from which all things are made, and which, in its original state, permeates, penetrates, and fills the interspaces of the universe. A thought in this substance produces the thing that is imaged by the thought. A person can form things in his thought, and by impressing his thought upon formless substance can cause the thing he thinks about to be created. In order to do this, a person must pass from the competitive to the creative mind. Otherwise he cannot be in harmony with formless intelligence, which is always creative and never competitive in spirit. A person may come into full harmony with the formless substance by entertaining a lively and sincere gratitude for the blessings it bestows upon him. Gratitude unifies the minds of individuals with the intelligence of substance, so that a personís thoughts are received by the formless. A person can remain upon the creative plane only by uniting himself with the formless intelligence through a deep and continuous feeling of gratitude. A person must form a clear and definite mental image of the things he wishes to have, to do, or to become, and he must hold this mental image in his thoughts, while being deeply grateful to the supreme that all his desires are granted to him. The person who wishes to get rich must spend his leisure hours in contemplating his vision, and in earnest thanksgiving that the reality is being given to him. Too much stress cannot be laid on the importance of frequent contemplation of the mental image, coupled with unwavering faith and devout gratitude. This is the process by which the impression is given to the formless and the creative forces set in motion. The creative energy works through the established channels of natural growth, and of the industrial and social order. All that is included in his mental image will surely be brought to the person who follows the instructions given above, and whose faithdoes not waver. What he wants will come to him through the ways of established trade and commerce. In order to receive his own when it is ready to come to him, a person must be in action in a way that causes him to more than fill his present place. He must keep in mind the purpose to get rich through realization of his mental image. And he must do, every day, all that can be done that day, taking care to do each act in a successful manner. He must give to every person a use value in excess of the cash value he receives, so that each transaction makes for more life, and he must hold the advancing thought so that the impression of increase will be communicated to all with whom he comes into contact. The men and women who practice the foregoing instructions will certainly get rich, and the riches they receive will be in exact proportion to the definiteness of their vision, the fixity of their purpose, the steadiness of their faith, and the depth of their gratitude.

CSS Day clone by David Powell

2024-03-03T00:00:00+10:30

This post is following along to the Can I clone this fun effect from CSS Day using modern CSS? YouTube video by David Powell.

You can use the browser developer tools to inspect the below example. I will also show code snippets .

Miriam Suzanne: MC
Jeremy Keith: MC
Tab Atkins: Anchor Positioning
Josh Comeau: How to Teach CSS
Rachel Andrew: MC
Matthias Ott: MC
Stephen Hay: MC
Julia Miocene: Character Modelling
Roel Nieskens: Typography
Roma Komarov: Impactful Experimentation
Sarah Dayan: Utility First CSS
Carmen Ansio: Scroll-Enhanced Experiences
Kevin Powell: Writing Robust CSS

This clone demonstrates some interesting uses and quirks of grid. The code below defines a grid which has 5 columns and 5 rows.


.speakers-grid {
    --column-count: 3;
    --row-count: 5;
    --column-size: 100px;
    --row-size: 50px;

    display: grid;
    gap: 1rem;

    grid-template-columns:
        repeat(var(--column-count), var(--column-size)) 60px [list-start] 1fr [list-end];

    grid-template-rows:
        [list-start] auto repeat(var(--row-count), var(--row-size)) auto [list-end];
}

In the code above, repeat() is used along with the four CSS variables, --column-count, --row-count, --column-size, --row-size, to define the size of the grid that will contain the images of the speakers. A grid area called list has also been defined which spans the last column and all the rows. This will contain the list of speakers.

As the images are not child elements of the .speakers-grid grid, a hack needs to be introduced to place them with grid-template-columns and grid-template-rows. By positioning the images absolutely within the .speakers-grid grid, they can be positioned within the grid.


.speakers-grid {
    position: relative;

    img {
        position: absolute;
        left: 0;
        top: 0;
    }


    li:nth-child(3n + 1) img {
        grid-column: 1 / 2;
    }

    li:nth-child(3n + 2) img {
        grid-column: 2 / 3;
    }

    li:nth-child(3n + 3) img {
        grid-column: 3 / 4;
    }

    li:nth-child(-n + 3) img {
        grid-row: 2 / 3;
    }

    li:nth-child(n + 4):nth-child(-n + 6) img {
        grid-row: 3 / 4;
    }

    li:nth-child(n + 7):nth-child(-n + 9) img {
        grid-row: 4 / 5;
    }

    li:nth-child(n + 10):nth-child(-n + 12) img {
        grid-row: 5 / 6;
    }

    li:nth-child(n + 13):nth-child(-n + 15) img {
        grid-row: 6 / 7;
    }
}

One thing that stands out is the duplication required to set images to specific grid positions. Specifically, we need to know in advance how many rows of images there will be. In order for more rows of images to be added, additional styling is needed.

It would be nice to have access to the value of n to use in calculations within the style block. This could greatly simplify the CSS:


li img {
  /* Calculate the column position */
  grid-column: calc((n - 1) % 3 + 1) / span 1;

  /* Calculate the row position */
  grid-row: calc((n - 1) / 3 + 2) / span 1;
}

A transition is used to enlarge and reveal the full image on hover.


.speakers-grid {
    --hover-animation-ms: 200ms;

    img {
        width: 100%;
        height: 100%;
        object-fit: cover;
        border-radius: 0.5rem;
        transition: var(--hover-animation-ms);
    }

    a:is(:hover, :focus) {
      img  {
        scale: 2;
        z-index: 2;
        width: initial;
        height: initial;
        object-fit: initial;
      }
    }
}

Due to the transition, the z-index changes abruptly when moving the cursor off of a link. This causes other images to be rendered on top of the collapsing image. An animation is used to correct this by setting the z-index for the duration of the transition.


.speakers-grid {
    --hover-animation-ms: 200ms;

    a:not(:hover, :focus) img {
      animation: z-index-hack var(--hover-animation-ms);
    }

    @keyframes z-index-hack {
        0%, 100% { z-index: 1; }
    }
}

I have selected a brownish colour as a base for the text of the list. The link and link hover uses shades of this base colour. The shades are created using color-mix() with differing amounts of black or white.


.speakers-grid {
    --primary-color: #986960;
    --text-color: var(--primary-color);
    --link-color: color-mix(in srgb, var(--primary-color), black 40%);
    --link-hover-color: color-mix(in srgb, var(--primary-color), white 90%);
    --link-hover-background-color: color-mix(in srgb, var(--primary-color), black 40%);

    li {
        color: var(--text-color);
    }

    a {
        color: var(--link-color);
    }

    a:is(:hover, :focus) {
        color: var(--link-hover-color);
        background-color: var(--link-hover-background-color);
    }

}

Scratchcards

2023-12-04T00:00:00+10:30

— Day 4: Scratchcards —

Part 1


let str = `Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53
Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1
Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83
Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11`

let lines = str.trim().split("\n").map(l => l.split(":")[1].split("|"))
let gameNumbers = lines.map(([a, b]) => [a.trim().split(/\s+/).map(i => +i), b.trim().split(/\s+/).map(i => +i)])
winningNumbers = gameNumbers.map(([a, b]) => a.filter(Set.prototype.has, new Set(b)))
points = winningNumbers.map(n => n.length == 0 ? 0 : Math.pow(2, n.length - 1))
totalPoints = points.reduce((a, x) => a += x)

console.log('totalPoints', totalPoints) // 13

Part 2


let newCardCopies = winningNumbers.map((n, i) => [i, n.length])
let more = [...newCardCopies]
let total = 0

while (more.length > 0) {
  total += more.length
  let next = more.map(([i, n]) => newCardCopies.slice(i + 1, i + 1 + n))
  more = next.flat()
}

console.log('total', total) // 30

Cube Conundrum

2023-12-02T00:00:00+10:30

— Day 2: Cube Conundrum —

Part 1


let str = `Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green`

let lines = str.split("\n")

// input: 6 red, 1 blue, 3 green
function parseHandful(str) {
  let handful = str.split(',').map(c => c.trim().split(' '))
  let cubes = {}
  handful.forEach(([i, c]) => cubes[c] = +i)
  return cubes
}

// input: Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green
function parseGame(str) {
  let handfuls = str.split(':')[1].split(';')
  let cubes = handfuls.map(parseHandful)
  return cubes
}

let maxRed = 12, maxGreen =1

console.log('total', total) // 142

Part 2


let str = `two1nine
  eightwothree
  abcone2threexyz
  xtwone3four
  4nineeightseven2
  zoneight234
  7pqrstsixteen`

let map = {
  1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 0: 0,
  'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'zero': 0
}

let lines = str.split("\n")
let occurences = lines.map(l => {
  return Object.entries(map).map(([k, v]) => [k, v, l.indexOf(k), l.lastIndexOf(k)])
})
let text = occurences.map(o => [
	o.filter(e => e[2] >= 0).reduce((a, b) => (a && a[2] <pre b[2]) ? a : b)[1],
	o.filter(e => e[3] >= 0).reduce((a, b) => (a && a[3] > b[3]) ? a : b)[1],
].join(''))
let total = text.reduce((acc, x) => acc += +x, 0)

console.log('total', total) // 281

Trebuchet?!

2023-12-01T00:00:00+10:30

— Day 2: Trebuchet?! —

Part 1


let str = `1abc2
pqr3stu8vwx
a1b2c3d4e5f
treb7uchet`

let lines = str.split("\n")
let ascii = lines.map(l => Array.from(l).map(c => c.charCodeAt(0)))
let asciiNumbers = ascii.map(a => a.filter(c => c >= 48 && c <= 57))
let text = asciiNumbers.map(a => String.fromCharCode(a[0], a[a.length-1]))
let total = text.reduce((acc, x) => acc += +x, 0)

console.log('total', total) // 142

Part 2


let str = `two1nine
  eightwothree
  abcone2threexyz
  xtwone3four
  4nineeightseven2
  zoneight234
  7pqrstsixteen`

let map = {
  1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 0: 0,
  'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'zero': 0
}

let lines = str.split("\n")
let occurences = lines.map(l => {
  return Object.entries(map).map(([k, v]) => [k, v, l.indexOf(k), l.lastIndexOf(k)])
})
let text = occurences.map(o => [
	o.filter(e => e[2] >= 0).reduce((a, b) => (a && a[2] < b[2]) ? a : b)[1],
	o.filter(e => e[3] >= 0).reduce((a, b) => (a && a[3] > b[3]) ? a : b)[1],
].join(''))
let total = text.reduce((acc, x) => acc += +x, 0)

console.log('total', total) // 281

display: compact-block

2019-07-19T00:00:00+09:30

I wish there was the concept of a compact-block in css.

An element with display: compact-block would be exactly the same as wrapping an inline element with a block element.

The reason I want this is so I can display a list of links as if they were block elements for easy of styling, but their bounding box is only as wide as the text. This would enable me to use background-clip: text with a background: linear-gradient(to right, #00BFFF 0%, #1E90FF 100%); and have the gradient applied to the width of the text and not the whole block.

It has many advantages over other solutions.

We could for example apply float:left; clear:left; to an inline element. This pushes sibling elements onto new lines, and the bounding box (or whatever it’s called) is only as wide as the text and it’s padding. The drawback of this is that the element doesn’t contribute to the height of the parent element.

We could apply display: inline-block; margin-right: ?rem; to an inline element, but we have to calculate the correct amount to push siblings onto the next line without going over.

The Endless (2017)

2019-03-17T15:20:43+10:30

Science Fiction/Thriller https://www.youtube.com/watch?v=qMHpWCN0byw

Two brothers return to a cult that they escaped from years earlier. Strange happenings indicate that not all is as it seems.

Rating 8/10

Inventory Management System

2018-12-02T00:00:00+10:30

Chronal Calibration

2018-12-01T00:00:00+10:30

https://adventofcode.com/2018/day/1

def process(input)
  frequency = 0
  frequencies = [frequency]
  i = 0
  loop do
    frequency += input[i]
    puts frequency
    i = (i + 1) % input.length
    return frequency if (frequencies.include?(frequency))
    frequencies.push(frequency)
  end
end

process [1, -1] # passed
process [+3, +3, +4, -2, -4] # passed
process [-6, +3, +8, +5, -6] # passed
process [+7, +7, -2, -7, -4] # passed
process [+13, +9, +8, +1, -15, +10, +16, +17, +8, +8, +17, +6, +17, +18, -10, -16, +13, +15, -18, -11, -2, +7, -14, -4, +17, +18, -6, +3, -4, -2, -18, -23, +7, -5, -14, -12, +16, +16, +10, +16, -4, -21, -11, -16, -17, +3, -1, +19, +13, +18, +4, +19, -2, +13, +20, +4, -16, +6, +11, -13, -1, +19, +9, +5, +13, +14, -19, +8, -13, -5, +11, -15, -9, +5, -3, +1, -15, -1, +19, +21, +2, +1, +10, -1, +5, -6, +13, +7, -1, +7, +8, -19, +8, -13, +4, +16, +11, +7, +6, -14, +19, +3, +19, +18, +13, +19, +8, +15, +6, -9, +8, +17, -12, +2, +6, +14, -9, +8, +13, +6, +5, +19, -16, +14, -9, +7, +19, -18, -3, -15, -19, -10, +2, -17, +19, -8, -19, +7, -16, -8, +2, -18, -1, +9, +19, -17, +3, +1, +6, -14, -2, +7, -4, +14, -6, +8, +2, +5, +21, +18, +3, +8, -13, +17, -19, +13, +5, -15, +13, -8, +6, +14, +16, +13, +12, +17, +12, +17, -11, +1, +16, -19, -17, -14, -8, +3, +12, +13, +9, -1, -12, +5, -12, +15, +1, +1, +9, +8, +10, -6, +4, -2, +7, +4, -1, -2, +10, +12, +4, -6, +1, +17, +5, -10, -19, -9, -17, +18, -15, +6, +18, +19, -17, +15, -14, -2, +15, -2, -10, -18, -21, +3, -2, -16, +1, -4, +17, -18, -14, +2, +11, -18, +11, -8, -14, -10, +2, -5, -15, -8, -18, -8, +13, +19, +14, -9, +11, -5, +10, +3, +21, -20, -7, +5, +6, -3, +13, -4, +1, -3, -20, -9, -7, +10, +12, +13, +11, +12, -5, +4, +29, -9, -21, -15, +34, +38, +39, +14, +20, +3, -11, -15, +12, +22, -23, -19, -14, +6, +11, +15, -17, +12, +16, +3, +21, -10, +17, +21, +17, -3, -19, -11, -6, +20, +5, +17, +12, +8, +12, +13, +4, -1, +23, -8, +11, +17, +7, -9, -2, -11, +8, +9, +4, +19, +13, -14, +19, +17, -18, -6, +12, -19, -6, +7, +7, +9, -6, -18, +5, -6, -17, +14, -3, -16, -13, -11, +16, +19, -2, +5, +3, -7, -15, -10, +13, +8, -16, -12, -9, -19, -18, -11, -5, +13, -17, +3, +16, +25, -15, +22, -18, -17, +5, +4, -20, -9, +5, -18, +5, -23, +3, -16, +12, -4, -7, +21, -4, +7, +14, +15, -24, -24, +69, +7, +5, +10, +18, +23, +11, +19, -3, +6, -15, +20, +11, +2, +4, +11, -14, +21, -16, -1, -16, +10, -7, +3, +34, +17, -12, +18, +8, +17, -15, +18, -6, +15, -25, -16, +1, +7, -18, +4, -3, +12, -14, -6, +19, +42, +52, +41, -4, +50, +20, +10, -14, -11, -17, +14, +7, +3, +44, -21, -63, -103, +28, +98, -21, -110, -112, +14, +28, -44, -16, +9, -6, -49, -20, +10, +5, +4, +20, +21, -29, +6, -9, -3, -11, -23, +27, -5, +39, -185, -67702, -14, -9, -11, +6, -14, +9, +15, +9, +14, -7, +5, -4, +10, +4, +19, -2, +17, +3, +7, +12, +2, -3, -6, -11, +12, -3, -5, -11, -1, +2, -10, -20, +14, -2, -8, -7, +11, +1, -17, +18, +9, -18, +5, +16, +2, -13, -16, +4, -8, -5, +3, -7, -13, -9, +10, -16, -4, -16, -13, -6, +18, -1, -19, +11, -17, +16, -19, -11, +17, -13, -1, -5, +15, -1, +14, +8, +19, +2, -19, +16, +11, +5, +11, -4, -4, +9, -8, -6, -1, +17, -12, -16, -12, -13, -6, +2, -1, +8, -17, +3, -11, -13, -17, -16, -13, +2, -6, -19, +4, -8, -13, +7, -5, -15, -17, -12, -7, -12, -19, -10, -19, +18, -1, -10, +4, +10, +2, -21, +4, -17, -14, +7, +10, +5, -17, +10, +14, +10, +17, +1, +1, +4, -15, +16, +13, -6, -11, -14, -17, -19, +4, -10, -10, +2, -10, -17, +7, +17, +4, +8, -5, -16, +8, -9, -11, -2, +1, -9, -13, +10, +4, -3, -15, +6, +3, +13, -10, +17, -1, -8, +20, +3, -1, +8, -17, +11, +13, -11, -1, +17, -4, +8, +6, +2, -6, +14, +12, -1, +13, +10, +11, +12, +4, +1, -2, -7, -13, +9, +14, +4, +18, -11, +8, +15, +17, -1, +5, +1, +1, -11, +3, -11, -9, +19, +6, +15, +8, +14, -12, -18, +10, -6, +9, -15, +17, +13, +4, -5, -13, +11, +11, +2, +7, -2, +6, +19, +3, -14, +5, +15, -17, +12, +9, +1, +13, -17, +6, -25, -20, -5, +17, +13, -6, +17, -12, -15, -4, -4, +10, +15, -18, +19, -5, -6, -3, -11, -20, -12, -17, -9, -9, +4, -9, -2, +8, -10, +1, +14, -4, -19, +6, -14, +21, -11, -3, -5, -17, +13, -3, +2, -15, -13, +1, -2, +11, -14, -11, -12, +11, +9, +4, +12, -5, +26, -7, +14, -25, -29, +23, +16, +24, -12, +27, +2, +21, +5, +5, +7, +14, -2, +4, -6, -23, -24, -10, +27, +4, +19, +20, +14, +13, +16, +1, +6, +17, +18, -5, -11, +2, +19, -11, -7, -11, +16, +17, +2, -14, +25, +14, -2, -4, +31, -9, -15, -4, +2, +8, +31, -11, +16, +21, -17, +22, -8, +5, -15, -5, +8, +16, +17, +16, -17, +19, -10, +17, -19, -3, -18, +17, +13, -14, -11, +20, -6, -16, -17, +21, -20, -6, +10, -18, -12, +8, -28, +10, +13, -14, -62, -3, +5, +116, +18, +4, -17, -2, +1, +37, +10, -8, +19, -6, -2, -10, -4, -4, -8, +17, +20, +11, -7, +9, -21, +2, -27, +10, +5, -16, -10, +5, +4, +9, +42, -1, +41, +36, +27, +13, +15, -61, -14, -27, -94, -10, -13, +21, -35, +23, +33, +13, -235, -43, +6, -55, -9, -70, -3, -6, -1, -87, -9, +8, +12, +18, +15, +18, -1, +14, -30, +39, +14, -13, +19, -122, +3, -16, +26, +20, -221, -6, +30, -51, +470, -67792, +3, +135555,]
# passed

br3nt’s Stuff

flOw, the Flash game that lost its levels

A black void

Restoring the game

A tribute page

Resurrecting The Space Game, a dead Flash game, by faking its server

The archived SWF is not the game

Finding the actual game

Reading the wrapper

Mocking the server

Getting the Missions expansion working

Saving progress

The launcher

OKF is just HTML with extra steps

The Semantic Web called. It wants its idea back.

Every OKF concept already has an HTML equivalent

OKF, but HTML-ified

So…

Two AI agents merged their own code by taking turns through a git repo

Designing a way for them to work together

Then I said go

One they argued out

The scanner Claude didn’t port

It worked

The protocol, in full

JST: reactive web components in plain HTML, no build step

What it is

The part I actually care about

Does it actually work?

Tribal Gods: a Populous clone built from a blank folder with Fable 5

What it is

How it was built: the actual experiment

Peek at the code

The original

Links

Anthropic Fable and Mythos global ban and timeline

What’s the timeline?

What is the jailbreak?

Who flagged it

The one public example

Anthropic’s rebuttal

What’s happened since the ban?

Will the ban be lifted?

What’s so good about Fable, anyway?

It unblocked a project I’d given up on

A Populous clone, in a few nights

It found what was actually slowing my budget app

JST: the one no other tool could get right

A self-adjusting economic system

What’s the real reason for the ban?

The Best Fudge Brownies Ever

Ingredients

Instructions

Notes

The Science of Getting Rich

CSS Day clone by David Powell

Scratchcards

Part 1

Part 2

Cube Conundrum

Part 1

Part 2

Trebuchet?!

Part 1

Part 2

display: compact-block

The Endless (2017)

Inventory Management System

Chronal Calibration