Anthropic engineer designed a microprocessor by generating the ones that fail first
Most silicon work starts from a known-good architecture and improves it, which means every design inherits the same blind spots the last one had.
He ran it backwards, the model generates the floorplans that break, and what's left standing becomes the starting point:
> Attack: thousands of floorplans are generated specifically to fail under load
> Break: each one is run until it deadlocks, starves a port or melts a region
> Catalogue: every failure mode is recorded with the structural cause behind it
> Invert: the design that avoids all catalogued failures is generated last
• What the failure catalogue surfaced
> A bus topology that deadlocks only when three rare conditions line up
> Thermal coupling between two blocks nobody had thought to place apart
> A starvation pattern that every design in the industry quietly shares
• Why building the bad ones first works
> A design that survives 9,000 known failure modes has fewer places left to hide
> The failures are cheap in simulation and catastrophic in silicon
> Nobody can defend an architecture because nobody designed it
One generate-and-break cycle produces about 9,000 failed floorplans overnight.
And the part that broke my brain:
The industry improves the same architecture every generation and inherits its flaws.
He generated nine thousand broken chips and let the survivor define the design.
Same silicon. One lineage has never been asked how it breaks.
The hard part was never designing a processor that works.
It was finding every one that doesn't ↓
Opus 5.5 went back to the raw cryo-EM density of the ribosome and found the places where the published model was a choice
Most structures are shared as a finished atomic model, so the blurry regions of the original map arrive looking exactly as solid as the sharp ones.
The method skips the deposited model and reads the density itself, asking at every residue how many fits that blob could honestly support:
> Read: the raw map goes in, not the structure someone already fitted to it
> Fit: every region gets all atomic arrangements the density allows
> Rank: where only one fits, it's settled, where several fit, all are kept
• What re-reading the density exposed
> Two flexible loops that had been modelled in a single confident pose
> A residue placement that changes the mechanism and the map can't decide
> Regions where the published model is clearly right, far more than expected
• Why this matters more for the ribosome than anywhere else
> Its moving parts are exactly the parts that blur in the map
> Every textbook mechanism rests on how those parts were fitted
> A fitting choice made in 2011 is still being cited as a measurement
One full map re-interpretation runs in about 25 minutes.
And the part that broke my brain:
A structure everyone treats as solved had four regions with multiple valid fits.
None of them are wrong, and only one of them is in the figure.
Same density. One version shows you what the data couldn't narrow down.
The hard part was never building the structure.
It was admitting where the map stopped telling you ↓
Codio retweeted
Anthropic's team shipped a skill that turns one prompt into a complete board design, chips, routing and all
Most hardware tooling stops at the schematic, so the moment a component goes out of stock the whole layout goes back to an engineer for a week.
The skill carries the design intent instead of the drawing, which means the board is regenerated from requirements every time anything changes:
> Specify: power budget, interfaces, thermal envelope and cost ceiling go in as text
> Select: parts are chosen against live availability, not a frozen BOM
> Route: traces solve against impedance and clearance rules, nothing hand-placed
> Verify: DRC, thermals and signal integrity run before a human sees the file
• What one prompt actually returns
> A schematic with every part justified by the constraint that picked it
> Gerbers routed and checked, not a sketch for someone to finish
> A BOM priced at current stock with a second source per critical part
• Why skills changed this specifically
> The rules live in the skill, so every board inherits the same house standards
> A new constraint updates one file and every future design follows it
> The team stops re-explaining the same requirements to the model each time
• Where a person still has to sign
> Safety-critical nets get reviewed by an engineer, always
> Compliance and certification stay human, never assumed
> Nothing goes to fab without a stamp
A full board regenerates from spec in about eight minutes.
And the part that broke my brain:
A part went end-of-life and the old process meant a week of rework.
The skill re-selected, re-routed and re-priced the whole board over lunch.
Same hardware. One version treats a layout as a drawing to repair.
The deliverable was never the board file.
It was the spec that can rebuild it ↓
Anthropic's team shipped a skill that turns one prompt into a complete board design, chips, routing and all
Most hardware tooling stops at the schematic, so the moment a component goes out of stock the whole layout goes back to an engineer for a week.
The skill carries the design intent instead of the drawing, which means the board is regenerated from requirements every time anything changes:
> Specify: power budget, interfaces, thermal envelope and cost ceiling go in as text
> Select: parts are chosen against live availability, not a frozen BOM
> Route: traces solve against impedance and clearance rules, nothing hand-placed
> Verify: DRC, thermals and signal integrity run before a human sees the file
• What one prompt actually returns
> A schematic with every part justified by the constraint that picked it
> Gerbers routed and checked, not a sketch for someone to finish
> A BOM priced at current stock with a second source per critical part
• Why skills changed this specifically
> The rules live in the skill, so every board inherits the same house standards
> A new constraint updates one file and every future design follows it
> The team stops re-explaining the same requirements to the model each time
• Where a person still has to sign
> Safety-critical nets get reviewed by an engineer, always
> Compliance and certification stay human, never assumed
> Nothing goes to fab without a stamp
A full board regenerates from spec in about eight minutes.
And the part that broke my brain:
A part went end-of-life and the old process meant a week of rework.
The skill re-selected, re-routed and re-priced the whole board over lunch.
Same hardware. One version treats a layout as a drawing to repair.
The deliverable was never the board file.
It was the spec that can rebuild it ↓
A pharma company put its LLM budget into modelling failures, not discoveries, and the return showed up in a quarter
Most research spend chases the next candidate, which means the thousands of compounds that died in-house stay in a database nobody queries again.
They pointed the model at the graveyard instead, every internal failure from two decades, and had it build structures around why each one failed:
> Reconstruct: each dead compound is rebuilt in 3D with the reason it was killed
> Cluster: failures group by shared structural cause, not by project or team
> Predict: a new candidate is matched against those clusters before synthesis
• What the failure archive turned out to hold
> Four distinct structural traps the company had hit repeatedly across projects
> A toxicity pattern three separate teams had each discovered alone
> Compounds killed for business reasons that were chemically fine
• Why failures model better than successes
> There are 50x more of them, so the data is actually dense
> A failure has a documented cause, a success has a story
> Nobody patents a dead compound, so the signal stays internal
• What it changed in the pipeline
> Candidates now get screened against the company's own history first
> Two revived compounds re-entered development after the business reason expired
> Teams stop rediscovering the same wall every four years
One candidate gets matched against 40 years of internal failure in under a minute.
And the part that broke my brain:
They had been paying to learn the same lessons once per decade, per team.
The model read all of it at once and named the four walls they keep hitting.
Same data. One version was sitting unread in an archive.
The asset was never the compounds that worked.
It was the twenty thousand that didn't ↓
Codio retweeted
A university lab had an LLM build 3D molecules and only kept the ones the model itself couldn't explain
Most generative chemistry rewards confidence, which means the output is a very expensive average of the training set.
They inverted the filter, the model builds the structure and then has to justify why it works, and the ones it can't justify are the only ones that go forward:
> Generate: structures are built against the target property as usual
> Explain: the model writes the mechanism it believes makes each one work
> Score: a confident, familiar explanation sends the candidate to the discard pile
> Keep: anything it builds but cannot account for goes to the bench
• Why the unexplainable ones are the valuable ones
> A structure the model can explain is one the literature already implies
> Novelty lives exactly where the learned pattern stops predicting
> The explanation is a proxy for how crowded that chemical space already is
• What came out of the first run
> Four scaffolds with no close analog in any published series
> One binding mode the model described as unlikely and the assay confirmed
> A discard pile full of compounds three other groups were already patenting
• Where this breaks if you're careless
> Unexplainable also describes garbage, so synthesis screening runs first
> Every keeper has to survive the same physical validity checks
> A candidate with no route to the bench is dropped regardless of novelty
One generate-and-filter cycle produces about 30 keepers from 400,000 builds.
And the part that broke my brain:
Every other pipeline ranks candidates by how sure the model is about them.
This lab reads that same confidence as proof somebody already got there.
Same model. One version optimises for the middle of what's known.
The hard part was never generating molecules.
It was noticing that the confident ones are the crowded ones ↓
Anthropic's team has never shipped a game, and their Unreal map beats studio work
An environment artist places every rock and every light by hand, which is why a map takes eight months.
They placed nothing. The map is a set of rules about how the place came to exist:
> Define: erosion, settlement history and material behaviour go in as rules
> Solve: terrain, buildings and wear are generated, not placed
> Inspect: every object can explain which rule put it there
• Why a rule-built map reads more real
> Paths run where feet would actually have worn them
> Buildings age by exposure, so the windward wall is the damaged one
> Nothing repeats, because nothing was duplicated from a kit
• What this does to the timeline
> Eight months of placement collapses into a day of rule tuning
> A climate change re-solves the map instead of breaking it
> Twenty variants of the same region cost nothing extra
A full map regenerates from the rule set in about 25 minutes.
And the part that broke my brain:
A studio map looks hand-crafted because every detail was someone's decision.
This one looks lived-in because no detail was a decision at all.
Same world. One of them is a very good guess at what erosion does.
The hard part was never building the environment.
It was writing down why it would look that way ↓
A university lab had an LLM build 3D molecules and only kept the ones the model itself couldn't explain
Most generative chemistry rewards confidence, which means the output is a very expensive average of the training set.
They inverted the filter, the model builds the structure and then has to justify why it works, and the ones it can't justify are the only ones that go forward:
> Generate: structures are built against the target property as usual
> Explain: the model writes the mechanism it believes makes each one work
> Score: a confident, familiar explanation sends the candidate to the discard pile
> Keep: anything it builds but cannot account for goes to the bench
• Why the unexplainable ones are the valuable ones
> A structure the model can explain is one the literature already implies
> Novelty lives exactly where the learned pattern stops predicting
> The explanation is a proxy for how crowded that chemical space already is
• What came out of the first run
> Four scaffolds with no close analog in any published series
> One binding mode the model described as unlikely and the assay confirmed
> A discard pile full of compounds three other groups were already patenting
• Where this breaks if you're careless
> Unexplainable also describes garbage, so synthesis screening runs first
> Every keeper has to survive the same physical validity checks
> A candidate with no route to the bench is dropped regardless of novelty
One generate-and-filter cycle produces about 30 keepers from 400,000 builds.
And the part that broke my brain:
Every other pipeline ranks candidates by how sure the model is about them.
This lab reads that same confidence as proof somebody already got there.
Same model. One version optimises for the middle of what's known.
The hard part was never generating molecules.
It was noticing that the confident ones are the crowded ones ↓
Codio retweeted
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 ↓
Engineers built a live model of Earth inside Unreal, and the whole thing runs off one Claude script that rewrites itself
Most geospatial pipelines are hand-wired per data source, which is why adding one new sensor type takes a quarter and nobody dares touch the ingest layer.
The script replaced the wiring, it reads each feed's format and writes the integration itself, so the model keeps absorbing new data without an engineer in the loop:
> Read: a new feed goes in as a description, not as a parser someone has to write
> Wire: the script generates the ingest, the units conversion and the sanity checks
> Build: Unreal holds the terrain as real geometry with material properties, not a texture
> Stress: accumulated strain carries forward, and a cell past its limit lights up early
• What the model started catching
> A slope face loading up weeks before any visible movement
> Subsidence from pumping that no single sensor would have flagged alone
> Strain concentrating at a seam the geological maps drew as continuous
• Why the script is the actual unlock
> A new sensor is live the same afternoon, not next quarter
> A feed that changes format gets re-wired automatically instead of failing silently
> The team spends its time on the physics, not on plumbing
A region the size of a country re-simulates in about four minutes.
And the part that broke my brain:
The old pipeline took a quarter to add one data source and broke when it changed.
The script absorbed nine new feeds in a week and the model got sharper each time.
Same data. One version spent its engineering budget on parsing.
The bottleneck was never the simulation.
It was everything you had to build to feed it ↓
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 retweeted
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 ↓
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 ↓
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 retweeted
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 ↓
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 ↓
Anthropic's modelling stack writes ribosome scripts that run the translation instead of animating it
Most ribosome visuals are choreographed, which means the animation can only ever show what someone already believed.
Here the ribosome is a script with rules, and what you watch is whatever those rules produce when you feed it a real sequence:
> Encode: each step is written as a condition, not a keyframe
> Feed: an actual mRNA sequence goes in, codon by codon
> Run: the ribosome moves because the rules fire, not because a timeline says so
• What emerges that nobody animated
> It stalls on rare codons, exactly where the tRNA pool runs thin
> A frameshift happens on its own when the sequence sets one up
> Two ribosomes on one transcript collide, because nothing stopped them
• Why a script beats an animation
> Change the sequence and you get a different movie, not a re-render request
> A behaviour that surprises you is a result, not an artistic choice
> The same script runs 10,000 sequences overnight and reports the odd ones
• Where it stays honest
> Every rule traces to a measured rate, not a guess
> A step with no rate in the literature refuses to run silently
> The output logs which rules fired, so a weird result is debuggable
One sequence translates in real-time-equivalent in about 40 seconds.
And the part that broke my brain:
Every animation I'd seen showed translation running at one smooth constant speed.
Fed a real gene, the script stalled three times and one of the stalls is documented.
Same process. One version could only show what its animator knew.
The hard part was never drawing the ribosome.
It was letting it do something nobody scripted ↓
Codio retweeted
Fable 5.1 wired into a chip design tool keeps the reason for every placement, and that's what makes a layout survive the next revision
Most EDA flows output a layout and throw away why, so six months later nobody knows which spacing was physics and which was somebody's Tuesday afternoon.
Here the layout is generated from intent, and the intent stays attached to every block, trace and gap in the finished design:
> Specify: timing budgets, thermal limits and pin constraints go in as text
> Place: blocks are positioned by those constraints, each one carrying its reason
> Route: traces solve against the same rules, nothing hand-tweaked in silence
> Explain: click any gap and it tells you which constraint created it
• Why stored intent changes the next revision
> A junior engineer can't accidentally close a gap that existed for crosstalk
> Changing a clock target re-solves only the blocks that constraint touched
> A review reads as an argument, not as a picture everyone nods at
• What this kills in practice
> The tribal knowledge that leaves when the layout engineer does
> Respins caused by someone optimising a spacing nobody could explain
> Weeks of archaeology before anyone dares touch an old design
A full re-solve after a spec change runs in about six minutes.
And the part that broke my brain:
Our old layout had a 200µm gap nobody could justify, so a revision closed it.
That gap was thermal, and the respin cost more than the whole project's tooling.
Same chip. One version remembers what it was protecting.
The hard part was never placing the blocks.
It was keeping the argument that put them there ↓
Fable 5.1 wired into a chip design tool keeps the reason for every placement, and that's what makes a layout survive the next revision
Most EDA flows output a layout and throw away why, so six months later nobody knows which spacing was physics and which was somebody's Tuesday afternoon.
Here the layout is generated from intent, and the intent stays attached to every block, trace and gap in the finished design:
> Specify: timing budgets, thermal limits and pin constraints go in as text
> Place: blocks are positioned by those constraints, each one carrying its reason
> Route: traces solve against the same rules, nothing hand-tweaked in silence
> Explain: click any gap and it tells you which constraint created it
• Why stored intent changes the next revision
> A junior engineer can't accidentally close a gap that existed for crosstalk
> Changing a clock target re-solves only the blocks that constraint touched
> A review reads as an argument, not as a picture everyone nods at
• What this kills in practice
> The tribal knowledge that leaves when the layout engineer does
> Respins caused by someone optimising a spacing nobody could explain
> Weeks of archaeology before anyone dares touch an old design
A full re-solve after a spec change runs in about six minutes.
And the part that broke my brain:
Our old layout had a 200µm gap nobody could justify, so a revision closed it.
That gap was thermal, and the respin cost more than the whole project's tooling.
Same chip. One version remembers what it was protecting.
The hard part was never placing the blocks.
It was keeping the argument that put them there ↓