Codio

[Codio @0xCodio]

https://t.co/IqYyc0CMd0

[Codio @0xCodio]

@0xWast3 a lot of resources and time were spent on this

[Codio @0xCodio]

A ribosome model that renders the molecules it rejects, and the protein almost disappears behind them

Most animations show the correct tRNA gliding in and docking, one clean arrival per codon, which is the one frame of the process that's least representative of it.

This one simulates the sampling itself, so every near-miss that arrives, gets tested and bounces off is drawn too:

> Sample: tRNAs arrive by diffusion, mostly wrong ones, at measured rates
> Test: each is held against the codon just long enough to fail
> Keep: the one that fits proceeds, and the count of rejects is logged per codon

• What the rejects actually look like
> Dozens of arrivals per codon, nearly all of them wrong and nearly all brief
> A near-cognate that fits well enough to linger, and still gets released
> The correct one showing up looking exactly like the others until it doesn't

• Why showing the failures matters
> Accuracy isn't recognition, it's rejection repeated until one survives
> The energy budget makes sense only once you count what got thrown away
> A mistranslation is visible as a near-miss that stayed half a beat too long

One codon renders with its full sampling history in about two seconds.

And the part that broke my brain:

The textbook version makes translation look like a key finding its lock.

The simulation looks like a door being tried by a crowd until someone's key works.

Same process. One version only shows you the molecule that succeeded.

The machine was never good at choosing.

It was relentless at refusing ↓

[Codio @0xCodio]

https://t.co/IqYyc0CMd0

[Codio @0xCodio]

@0xWast3 choosing the right option is important

[Codio @0xCodio]

@Lummox_eth thanks for sharing this tool

[Codio @0xCodio]

Opus 5.5 plugged into Unreal Engine doesn't build the level, it plays the level a million times and rebuilds what players break

Most procedural tools generate a map and hand it over, so the first thing a real player does is walk somewhere the designer never imagined and fall through the world.

Here the engine runs agents through the level before a human ever loads it, and the geometry changes based on what they actually did:

> Build: the level generates from the design intent, not from a tile set
> Play: thousands of agents run it with different skill levels and playstyles
> Watch: every death, stuck spot, skipped route and exploit gets logged
> Rebuild: the level regenerates to fix what the logs found, then runs again

• What the agents keep finding
> A ledge 94% of players walked past because the lighting hid it
> One corner where a crouching agent could see through the level
> A shortcut that cut the intended path in half and nobody designed

• Why playtesting first beats polishing first
> A level that survives a million agents has no obvious holes left to find
> Human testers get the interesting problems instead of the broken geometry
> The fix is a regeneration, not a week of manual blockout edits

One level goes through about 40 play-and-rebuild cycles overnight.

And the part that broke my brain:

A studio puts a level in front of 20 testers after three months of building.

This ran a million playthroughs before the first human opened the file.

Same level. One version finds its holes after the ship date.

The hard part was never generating the world.

It was finding out how players would break it ↓

[Codio @0xCodio]

@0xWast3 yeah and article actually specifies details regarding prices and tokens

[Codio @0xCodio]

Opus 5.5 plugged into Unreal Engine doesn't build the level, it plays the level a million times and rebuilds what players break

Most procedural tools generate a map and hand it over, so the first thing a real player does is walk somewhere the designer never imagined and fall through the world.

Here the engine runs agents through the level before a human ever loads it, and the geometry changes based on what they actually did:

> Build: the level generates from the design intent, not from a tile set
> Play: thousands of agents run it with different skill levels and playstyles
> Watch: every death, stuck spot, skipped route and exploit gets logged
> Rebuild: the level regenerates to fix what the logs found, then runs again

• What the agents keep finding
> A ledge 94% of players walked past because the lighting hid it
> One corner where a crouching agent could see through the level
> A shortcut that cut the intended path in half and nobody designed

• Why playtesting first beats polishing first
> A level that survives a million agents has no obvious holes left to find
> Human testers get the interesting problems instead of the broken geometry
> The fix is a regeneration, not a week of manual blockout edits

One level goes through about 40 play-and-rebuild cycles overnight.

And the part that broke my brain:

A studio puts a level in front of 20 testers after three months of building.

This ran a million playthroughs before the first human opened the file.

Same level. One version finds its holes after the ship date.

The hard part was never generating the world.

It was finding out how players would break it ↓

[Codio @0xCodio]

https://t.co/K4XPnqLy1A

[Codio @0xCodio]

@thegreatest_sv how many components are involved in the system?

[Codio @0xCodio]

@gippp69 how long did the complete cleaning take?

[Codio @0xCodio]

@0xWast3 looks cool, I’ll try testing it out

[Codio @0xCodio]

@0xrompasso many tests were conducted on this model

[Codio @0xCodio]

https://t.co/K4XPnqLy1A

[Codio @0xCodio]

@0xWast3 the article actually explains how to do this

[Codio @0xCodio]

A molecular model that only reports the connections no single paper could have seen

Most research builds one link at a time, a protein to a pathway, a pathway to a symptom, and each study stays inside the field that funded it.

This one holds every published link as a graph and goes looking for paths that cross fields nobody reads together:

> Link: 40 years of findings become edges, each dated and sourced
> Walk: it traverses paths of three and four hops across different literatures
> Surface: only paths where no two edges come from the same research group

• What crossing fields turns up
> A metabolic enzyme tied to a neurological symptom through two unrelated papers
> A drug side effect explained by a pathway described in agriculture research
> Two diseases sharing a mechanism neither field had reason to compare

• Why nobody found these by reading
> A four-hop path spans four journals nobody subscribes to at once
> Each individual edge is unremarkable, the path is the finding
> Specialisation is what makes the gap, not laziness

• How it avoids inventing connections
> Every hop names the paper and the year it held true
> A path with one expired edge is shown broken, not completed
> It proposes the experiment that would test the path, or drops it

One full traversal across the corpus runs in under three minutes.

And the part that broke my brain:

Two labs published halves of the same mechanism eleven years apart.

Neither cited the other, and nothing in either field would ever have connected them.

Same literature. One version can only see what someone already assembled.

The discovery was never in a new experiment.

It was sitting between papers nobody read together ↓

[Codio @0xCodio]

https://t.co/IqYyc0CMd0

[Codio @0xCodio]

@maestrooth and do you use each one?

[Codio @0xCodio]

@Lummox_eth together, it works several times better

[Codio @0xCodio]

@0xWast3 how many tokens did opus 5.5 spend on this?

[Codio @0xCodio]

A board and chip maker automated its entire design pipeline, and the first thing it automated was killing its own products

Most hardware firms automate the drawing, the routing, the BOM, and still spend a year building a device the market stopped wanting six months in.

They put the kill decision inside the loop, so a product has to keep justifying itself against the alternatives the pipeline just generated:

> Generate: the spec spawns 40 board variants, each with a real BOM and cost
> Simulate: thermals, signal integrity and yield run against every one of them
> Compare: each variant is scored against what a competitor could ship this quarter
> Cut: anything that can't win on cost, power or date is dropped before layout

• What automating the cut actually changed
> Two flagship boards died at week three instead of month nine
> The surviving design had a BOM 22% cheaper than the one humans picked
> Nobody defended a product because they'd already spent six months on it

• Why generating options beats refining one
> A single design gets better, but it never finds out it was the wrong design
> 40 variants surface the tradeoff nobody thought to ask about
> Sunk cost can't form in three weeks

A full generate-simulate-cut cycle runs in about nine hours.

And the part that broke my brain:

Their old process shipped one board a year and defended it the whole way.

The new one kills 39 designs a cycle and ships the one that survived everything.

Same engineers. One version never had to admit it picked wrong.

The hard part was never designing the hardware.

It was deleting the design you already loved ↓

[Codio @0xCodio]

@0xWast3 each frame of the model has its own meaning

[Codio @0xCodio]

A board and chip maker automated its entire design pipeline, and the first thing it automated was killing its own products

Most hardware firms automate the drawing, the routing, the BOM, and still spend a year building a device the market stopped wanting six months in.

They put the kill decision inside the loop, so a product has to keep justifying itself against the alternatives the pipeline just generated:

> Generate: the spec spawns 40 board variants, each with a real BOM and cost
> Simulate: thermals, signal integrity and yield run against every one of them
> Compare: each variant is scored against what a competitor could ship this quarter
> Cut: anything that can't win on cost, power or date is dropped before layout

• What automating the cut actually changed
> Two flagship boards died at week three instead of month nine
> The surviving design had a BOM 22% cheaper than the one humans picked
> Nobody defended a product because they'd already spent six months on it

• Why generating options beats refining one
> A single design gets better, but it never finds out it was the wrong design
> 40 variants surface the tradeoff nobody thought to ask about
> Sunk cost can't form in three weeks

A full generate-simulate-cut cycle runs in about nine hours.

And the part that broke my brain:

Their old process shipped one board a year and defended it the whole way.

The new one kills 39 designs a cycle and ships the one that survived everything.

Same engineers. One version never had to admit it picked wrong.

The hard part was never designing the hardware.

It was deleting the design you already loved ↓

[Codio @0xCodio]

https://t.co/L1qqCuhjV5