←
Codio719 posts
Codio avatar

Codio

@0xCodio
◷ Joined July 2026▧ 201 Photos and videos
Codio avatar
Codio@0xCodio·2h

A new Chinese tool found most dead boards hold two good chips that disagree Every chip gets tested on its own, so nobody checks if its pins agree with the chip on the other end. Every connection on the board is now read against both datasheets before a single trace gets routed: > Read: both datasheets pulled for every chip > Pair: each pin matched to the pin it talks to > Compare: voltage, timing and startup order on both sides > Fix: a level shifter, pullup or delay added where needed • What the pin check keeps catching > A 1.8 volt output into a 3.3 volt input > A clock faster than the receiver can latch > One chip waking up before the other is ready • What it changes for the team > Bring up starts with a board that boots > Datasheets read once, not by every engineer > Every link documented inside the design • What a person still signs off > Power sequencing on the final board > Anything that touches safety > The first boot on real hardware A board with forty chips gets every connection checked in about three minutes. One prototype refused to boot about one time in twenty and nobody could repeat it on the bench. The memory chip was waking up four milliseconds after the processor started talking to it. Neither chip was broken. The handshake between them was. How every pin gets checked against both sides is in the article below ↓

0:27
Codio@0xCodioOct 25

Codio @0xCodio Oct 25 Article Opus 5.5 Writes Unreal C++ Well. It Writes Blueprints Thirty Points Worse. Unreal 5.8 ships an official MCP server. Epic's own words: it "enables developers to connect models like Claude directly to UE projects." Then a benchmark gave seven models the same gameplay spec

Codio avatar
Codio@0xCodio·8h

Anthropic's team rebuilds parts for factory machines whose makers closed decades ago Half the machines on an old factory floor have no drawings left, so one broken gear can stop a line for months. The system rebuilds the part from photos of the broken one and the space it has to fit back into: > Scan: photos of the worn part and the slot it came from > Infer: the original size recovered from where the wear stops > Generate: a clean model plus drawings ready for the shop • What the rebuild recovers > True sizes from before the wear set in > Material read from the fracture marks > Fits checked against the mating parts • What it saves on the floor > No waiting on a maker that's long gone > No weeks of measuring the part by hand > A drawing finally on file for next time A broken part goes from photos to a model the shop can machine in about twenty minutes. One plant had a press down for eleven weeks waiting on a gear from a company that closed in 1994. The rebuilt one was cut the same afternoon, and the press ran that night. Most factories don't need new machines. They need the old ones to stop being orphans. How a part gets rebuilt from its own wear is in the article below ↓

0:25
Codio@0xCodioOct 11

Codio @0xCodio Oct 11 Article Opus 5.5 Writes Blender Python for the Wrong Blender - and the Render Won’t Tell You Two things go wrong when a model builds 3D in Blender, and neither is the geometry. The API moved under its training data, and the defects that matter are invisible in a render. Everything below is

Codio avatar
⟳ Codio retweeted
Codio@0xCodio·Nov 17

Engineering student automated helicopter wiring and the aircraft lost 40 kilos A helicopter carries kilometres of wire, and every run is still drawn by hand around parts already fixed in place. His tool generates the whole harness from the 3D airframe, with every connector, clamp and route solved together: > Map: every connector and its signal pulled from the systems list > Route: each wire pathed around heat and moving parts > Clamp: mounts placed where the airframe can carry them > Bundle: shared paths merged and every run cut to real length • What the generated harness fixes > Wire cut to length instead of left long > Routes kept clear of the hot engine bay > Shared paths bundled instead of doubled • What it changes in the hangar > Harness boards printed straight from it > A design change reroutes in minutes > Every wire traceable from plug to plug • What still goes past a person > Flight critical lines checked by hand > Certification signed by an engineer > First install inspected on the airframe A full harness for one airframe generates in about fifteen minutes. The hand drawn version carried forty kilos nobody needed, mostly slack and doubled runs. The generated one powered the exact same systems with all of that gone. On a helicopter every spare kilo of wire is fuel or cargo that stays on the ground. How the harness gets routed through the airframe is in the article below ↓

0:28
Codio@0xCodioOct 25

Codio @0xCodio Oct 25 Article Opus 5.5 Writes Unreal C++ Well. It Writes Blueprints Thirty Points Worse. Unreal 5.8 ships an official MCP server. Epic's own words: it "enables developers to connect models like Claude directly to UE projects." Then a benchmark gave seven models the same gameplay spec

Codio avatar
Codio@0xCodio·Nov 17

Anthropic's engineering team turned a week of factory drafting into four minutes The shop never builds from the 3D model, it builds from flat drawings someone dimensions by hand. Opus 5.5 generates the part and draws the shop sheets from it, sized the way a machinist actually measures: > Model: the part built from the spec with every feature tagged > Pick: views and sections chosen by what the shop needs to see > Dimension: every size taken from the edge the tool starts at • What the drawings get right by default > Sizes measured from the machining datum > Holes called out with thread and depth > One sheet for each setup on the machine • What disappears from the floor > Calls to engineering about a missing size > Parts cut to an old revision of a drawing > A week of drafting after every change Every revision redraws the whole set on its own, so nothing on the floor goes stale. On one line a third of scrapped parts traced back to a size taken from the wrong edge. The part was designed right. The drawing told the machinist something else. The 3D model was never what the factory read. The flat sheet was. How the sheets get drawn and checked is in the article below ↓

0:25
Codio@0xCodioOct 11

Codio @0xCodio Oct 11 Article Opus 5.5 Writes Blender Python for the Wrong Blender - and the Render Won’t Tell You Two things go wrong when a model builds 3D in Blender, and neither is the geometry. The API moved under its training data, and the defects that matter are invisible in a render. Everything below is

Codio avatar
⟳ Codio retweeted
Codio@0xCodio·Nov 16

Every floor plan looks bright on paper until you run a real winter through it Architects render one sunny afternoon, so nobody sees the flat that stays dark from November to March. Opus 5.5 builds the project in Unreal and runs a full year of real sun over the actual site: > Place: the building on its real plot with its real neighbours > Track: the sun moved hour by hour through all twelve months > Score: every room logged for direct light, glare and heat > Compare: each layout option run through the same year • What a full year turns up > Ground floor flats in shadow all winter > A glass corner office that cooks in August > A courtyard that only sees sun at noon • What changes in the design > Living rooms swap to the bright side > Balconies deepen where glare hits hardest > Unit prices follow hours of sun, not floor • Who reads the results > Buyers see real sun hours per flat > Planners check the shade cast on neighbours > Engineers size cooling to the actual heat A full year of light over one tower runs in about nine minutes. On one project the priciest penthouse came out darker than a third floor flat. A neighbouring tower nobody had modelled blocked it every winter morning. A render shows the best hour of the year. People live in all the others. How the year of light gets built and scored is in the article below ↓

0:25
Codio@0xCodioOct 25

Codio @0xCodio Oct 25 Article Opus 5.5 Writes Unreal C++ Well. It Writes Blueprints Thirty Points Worse. Unreal 5.8 ships an official MCP server. Epic's own words: it "enables developers to connect models like Claude directly to UE projects." Then a benchmark gave seven models the same gameplay spec

Codio avatar
Codio@0xCodio·Nov 16

Most printed rocket engine parts fail inside the printer and nobody sees it until the scan Engine parts are printed in metal layer by layer, and the heat from each layer bends the ones already underneath. Every part now gets printed virtually first, with the real laser path and the real angle on the build plate: > Layer: cooled the way the printer actually does it > Settle: stress tracked through the part as it grows • What the virtual print keeps catching > Thin walls bent out of shape by heat > Powder stuck in channels with no exit > Supports snapping off halfway through • What changes before the real run > The part gets rotated, not redesigned > Walls thicken where the heat piles up > A bad print costs minutes, not a week A full virtual print of an injector housing runs in about twenty minutes. One housing passed every design check and still came out of three real prints bent. Turning it forty degrees on the plate fixed it, and the drawing never changed. The design was right the whole time. The way it was printed wasn't. How the print gets simulated layer by layer is in the article below ↓

0:24
Codio@0xCodioOct 11

Codio @0xCodio Oct 11 Article Opus 5.5 Writes Blender Python for the Wrong Blender - and the Render Won’t Tell You Two things go wrong when a model builds 3D in Blender, and neither is the geometry. The API moved under its training data, and the defects that matter are invisible in a render. Everything below is

Codio avatar
⟳ Codio retweeted
Codio@0xCodio·Nov 15

A Chinese system puts 200 different chip designs on one wafer and lets the silicon pick Chip teams usually bet a year on one design and only find out if it works when the first wafer comes back. This system designs the variants, lays them out on a single wafer, then tests every die once it's printed: > Design: 200 small variants of one block > Print: all of them share a single wafer run > Probe: every die tested on the wafer • What changes between variants > Transistor sizing on the critical path > Spacing in the densest metal layers > Clock and power layout around hot spots • What the wafer reports back > Which ones hit speed and which ones leak > Where yield drops and where it holds > How far the simulator was from real silicon • What a person still owns > The target the variants are chasing > Sign off before full production > Anything safety critical, always One round goes from design to measured results in about six weeks. The variant the simulator ranked first came back 14th on real silicon. The winner was one nobody would have picked, and it had the best yield on the wafer. A simulator makes a guess. A wafer full of experiments gives an answer. How the variants get chosen and measured is in the article below ↓

0:26
Codio@0xCodioOct 25

Codio @0xCodio Oct 25 Article Opus 5.5 Writes Unreal C++ Well. It Writes Blueprints Thirty Points Worse. Unreal 5.8 ships an official MCP server. Epic's own words: it "enables developers to connect models like Claude directly to UE projects." Then a benchmark gave seven models the same gameplay spec

Codio avatar
Codio@0xCodio·Nov 15

Most devices fail certification over one metal part nobody saw near the antenna Antennas get placed last, after the case and board are locked, so whatever metal sits next to them just stays. Every new device is now modelled in 3D with its radio switched on, before a single prototype gets cut: > Place: antenna and every metal part at real size > Radiate: signal traced through the whole enclosure • What the radio pass keeps catching > A screw boss that detunes the antenna on its own > A battery blocking half the coverage > A cable running straight across the strongest field • Why it always showed up so late > Radio only gets tested on a finished prototype > Every fix means a new case and another lab slot > Certification labs are booked weeks ahead A full radio check on a new layout runs in about eight minutes. One tracker failed certification three times for a range problem nobody could explain. The model found a single steel screw sitting two millimetres from the antenna. The radio was fine every time. What got built around it wasn't. How the signal gets traced through a whole device is in the article below ↓

0:24
Codio@0xCodioOct 11

Codio @0xCodio Oct 11 Article Opus 5.5 Writes Blender Python for the Wrong Blender - and the Render Won’t Tell You Two things go wrong when a model builds 3D in Blender, and neither is the geometry. The API moved under its training data, and the defects that matter are invisible in a render. Everything below is

Codio avatar
⟳ Codio retweeted
Codio@0xCodio·Nov 14

This tool designs every chip so two rival fabs can build it the same week A chip is normally drawn for one factory's rules, so when that line is full or blocked the design just waits. The tool keeps both rulebooks open the whole time and only accepts geometry that each fab can print: > Load: design rules from both processes side by side > Solve: every block placed inside the tighter of the two > Prove: power signed off for each fab on its own • What building for two fabs costs > A few percent of area lost to the stricter rules > Slightly slower timing on the faster process > Two sets of masks budgeted from day one • What it buys a big company > A whole fab swapped out with no redesign > Price talks with a real alternative on the table > A shortage becomes a scheduling problem Moving production to the second fab took eleven days instead of the usual nine months. Last spring one line went down for a quarter and took a lot of other chips with it. This one kept shipping from the other factory, on the exact same files. Being stuck with one factory was never a law of physics. Nobody had a tool to avoid it. How the two rulebooks get merged into one design is in the article below ↓

0:27
Codio@0xCodioOct 25

Codio @0xCodio Oct 25 Article Opus 5.5 Writes Unreal C++ Well. It Writes Blueprints Thirty Points Worse. Unreal 5.8 ships an official MCP server. Epic's own words: it "enables developers to connect models like Claude directly to UE projects." Then a benchmark gave seven models the same gameplay spec

Codio avatar
Codio@0xCodio·Nov 14

Most devices bury the part that breaks first and one team stopped doing it Products are built to come together once in a factory, and nobody times how long they take to come apart. Every new device is rebuilt in 3D with real failure data on top, then taken apart the way a technician would: > Rank: parts ordered by how often they fail in the field > Strip: every step to reach it counted • What the teardown keeps exposing > A battery under the board, the board under the screen > A fan that needs the whole chassis out to swap > Glue where a single clip would have held • What changes before release > The part that fails most moves closest to the lid > Repair time gets reviewed next to the specs > Service manuals come from the teardown, not after it A full virtual teardown of a new design runs in about five minutes. One controller in the old layout took eleven steps and forty minutes to reach. After the redesign it was the first thing under the cover, and it took four. Nobody thinks about how a device comes apart until it has to. The teardown setup, from first screw to last, is in the article below ↓

0:25
Codio@0xCodioOct 11

Codio @0xCodio Oct 11 Article Opus 5.5 Writes Blender Python for the Wrong Blender - and the Render Won’t Tell You Two things go wrong when a model builds 3D in Blender, and neither is the geometry. The API moved under its training data, and the defects that matter are invisible in a render. Everything below is

Codio avatar
⟳ Codio retweeted
Codio@0xCodio·Nov 13

A Chinese plant building AI servers for big tech assembles every unit in Blender first, and keeps finding screws nobody can reach A design gets approved as a finished object, so nobody checks if the parts can actually go in one after another. Claude takes the CAD, rebuilds the server in Blender and runs the assembly the way the line would: > Order: every part goes in the sequence the line will use > Reach: each tool path is checked against what's already installed • What the dry run keeps finding > A screw sealed behind a bracket that went in first > A cable that only routes if the fan comes out > A heatsink that needs three hands to seat • What it changed on the floor > The build order gets fixed before unit one, not unit one hundred > Stations stop halting to call engineering > New designs arrive with the sequence already proven A full server goes through its virtual assembly in about seven minutes. The worst one passed every design review and still stopped a line for two days. One bracket had to go in before the screw it ended up covering. A design that looks finished isn't the same as one you can build. The whole dry run, part by part, is in the article below ↓

0:24
Codio@0xCodioOct 11

Codio @0xCodio Oct 11 Article Opus 5.5 Writes Blender Python for the Wrong Blender - and the Render Won’t Tell You Two things go wrong when a model builds 3D in Blender, and neither is the geometry. The API moved under its training data, and the defects that matter are invisible in a render. Everything below is

Codio avatar
Codio@0xCodio·Nov 13

A microscope wired to Claude Fable 5.2 found that 1 in 9 slides in a lab weren't what the label said Every analysis trusts the label, so a swapped sample gets measured perfectly and reported as something it isn't. Fable 5.2 reads the paperwork before it looks at anything, then checks whether the cells agree with it: > Read: protocol, label and expected cell type for every slide > Look: each field scanned, the cells actually there classified > Compare: a mismatch gets flagged before a single number is measured • What the mismatches turned out to be > Two slides swapped at the staining step > A culture taken over by a faster growing line > A control that had stopped being a control • Why nobody caught it before > Every tool downstream reads the label, not the cells > A tech checks focus and contrast, not identity > The results looked clean because the numbers were clean A full tray gets read and checked against its paperwork in about twelve minutes. Four months of results were sitting on one of those taken over cultures. Every measurement was right. It was just measuring a different cell. The analysis was never the weak spot. The sticker on the glass was. How the check is wired, step by step, is in the article below ↓

0:29
Codio@0xCodioOct 15

Codio @0xCodio Oct 15 Article Fable 5.1 Never Touches a Pixel. It Edits the Document Model Instead. The spec sheet says "Text and images → text." Four words, and they decide every workflow you can build on this model. It cannot paint, filter or composite. It can look at a render, and it can write

Codio avatar
⟳ Codio retweeted
Codio@0xCodio·Nov 12

Anthropic wrote a 3D generation document that no human is supposed to read, and it builds the models by itself Most tool docs are written for people, so they go stale the week the tool changes and nobody notices until a build breaks. This one is written for the model. Give it the file and one sentence, and it walks through the steps alone: > Read: the brief gets matched to the right section of the doc > Build: mesh, materials, rig and export, in order > Check: each result is tested against the rule its step was written for • What the instructions actually hold > Polygon budgets for every asset type > Naming rules every file has to follow > The tests a model must pass before it ships • Why nobody has to babysit it > A failed test sends the build back one step, not to the start > The doc is the process, so it can't fall behind the tool > A new rule is one added line, and every next build obeys it One sentence becomes a finished, rigged asset in about six minutes. Normally the docs say one thing and the pipeline quietly does another. Here they can't drift apart, because the document is the thing that runs. Nobody opens this manual, and that's exactly why it works. The whole document and how to plug it in are waiting below ↓

0:24
Codio@0xCodioOct 11

Codio @0xCodio Oct 11 Article Opus 5.5 Writes Blender Python for the Wrong Blender - and the Render Won’t Tell You Two things go wrong when a model builds 3D in Blender, and neither is the geometry. The API moved under its training data, and the defects that matter are invisible in a render. Everything below is

Codio avatar
Codio@0xCodio·Nov 12

This chip was built in 3D from 1,400 pages of datasheets, and not one number in it was made up Building a die from documentation means hundreds of small questions, and a normal model fills the gaps with guesses. Every question goes to XERJ Reader first. It can't write anything new, it can only point at text already in the file: > Ask: plain words, like how hot the package can run before it derates > Point: the exact clause comes back highlighted, with its position in the PDF > Refuse: if the datasheet never says it, the answer comes back empty • What changes in the build > Every pin pitch traces back to a page > A gap in the docs shows up as a gap, not a guess > A missing spec stops the build instead of bending it • What the pass costs > $0.01 per million input tokens, output is free > 80 ms per answer in batch, no token streaming > Hundreds of times cheaper than a frontier model One die took about 400 questions. Roughly a cent through Reader, around $4.80 through Opus 5.5. The first run asked for a thermal limit the datasheet never covered. A generator would have printed a confident number. Reader returned nothing, and that blank was the right answer. The 3D model is only as honest as the line behind each number. Reader waitlist opens today below ↓

0:24

I've built a new AI model that is not allowed to generate text. Instead, it produces a verifiable program that answers your prompt using the original reference. XERJ Reader-1 is a neurosymbolic model for working with data. It points to the exact words in your document, writes a small program over them, and exact code computes the answer: • 20-90x faster • 10-1,000x cheaper (output tokens free) • every answer is a program you can replay The shortest path to automating data work.

2:05