26 MBn | AI & Tech | Startups | Future of Work | Business | News | Automation
United States
Joined December 2023
- Tweets261
- Following81
- Followers43
- Likes322
Marc Edge retweeted
A fly's brain just beat-matched two tracks better than most humans on Twitch.
Not a metaphor.
This is a spiking neural network, modeled on an actual insect connectome, wired directly into a DJ rig.
No human hands on the faders.
The "Spike Raster" panel is the real signal, 1,640 neural spikes firing in a 20ms window, translating straight into deck moves: cueing, EQ sweeps, backspins, fader pulls from 0% to 100%.
Both tracks locked at 140 BPM. Transitions timed. Low end cut exactly when it should be.
Here's the part that should bother you.
DJing was supposed to be safe. Feel, timing, crowd-reading, that "human touch" nobody could code.
Turns out you don't even need a full brain to fake it. A few thousand spikes from an insect-sized network is enough to execute the skill end to end.
The jobs getting automated first aren't the boring ones.
They're the ones we assumed required a human somewhere in the loop.
What skill are you still calling "safe" because it feels human?
Marc Edge retweeted
Simulated Fruit Fly Brain learning TrackMania — MaleCNS v1.0, TECHCOS
60 minutes.
That's how long it took a simulated fruit fly brain to learn to race TrackMania from scratch.
Modeled on the insect's mushroom body — the tiny circuit that turns reward and punishment into learned behavior — it started with zero pretraining and no human demonstrations. Just a dopamine signal marking good moves and bad ones.
By the end, it was clearing jumps and hairpins at 250 km/h.
The whole model ran on 6,378 neurons. A real fruit fly brain has about 100,000 total — this used a sliver of that, just the reward-learning circuit.
Human brains run on 86 billion neurons. Frontier AI models run on hundreds of billions of parameters.
This ran on 6,378.
The lesson isn't that flies are smart. It's that scale was never the real bottleneck for learning — the reward signal and the architecture are.
That's a very inconvenient data point for every "AI just needs more compute" argument.
If a circuit this small can pick up a real-time physical skill in under an hour, the ceiling on what small, cheap, specialized systems can handle at work sits a lot higher than most people are pricing in.
Marc Edge retweeted
A fruit fly's brain just lit up exactly like yours does at 2am.
Someone mapped a real fly connectome and built a live simulation of it — every neuron cluster visualized, in real time.
Then they gave the fly a phone.
First scroll: dopamine at 17%.
It sees bananas.
Nothing happens.
It switches feeds.
A predator shows up — something moves, something turns its head.
Dopamine jumps to 34%.
The descending neurons fire.
The legs swipe the screen before the fly "decides" anything.
It saves a survival tip.
Five posts deep.
Eighteen seconds gone.
That's the whole loop, and you're watching it happen in raw neurons instead of theory.
Optic lobes catch the motion.
Central complex reorients.
Mushroom body tags it as worth repeating.
Same circuitry. Same order. Every species that's ever had to avoid getting eaten runs this exact sequence.
The apps in your pocket weren't built by guessing.
They were built by people who understand this circuitry better than you understand your own thumb.
Motion. Threat. Novelty. Reward. Repeat.
You don't get free will inside that loop.
You get a slightly slower nervous system than a fly.
The only real edge left is knowing the trigger before it fires.
Marc Edge retweeted
GPT-6 Astra vs Fable5.1 — same prompt, same rough motion reference.
Both start from the same abstract draft: pin-shaped bodies, no faces, blocked-out movement on an empty court.
From there each model renders its own final pass.
Astra's output: full bodies, real faces, rooftop courts, buildings in the background, players tracking the ball mid-air.
Fable5.1's output: full bodies, real faces, brick courtyards, headbands, sweat, shadows landing correctly on asphalt.
Same camera setups on both sides — overhead shots of the hoop, low-angle jump shots, the block at the rim, the crossover.
Two different finished renders from one shared starting point.
Marc Edge retweeted
50kg.
That's the instant lift capacity of Boston Dynamics' Atlas — the humanoid robot Hyundai now owns and is training on real car assembly lines.
Sustained, it holds 30kg for hours without slowing down.
This isn't a lab demo anymore.
Atlas is already sequencing parts, walking storage racks, and sharing factory floor space with human workers under real-time detection systems.
Here's what actually matters:
→4 hour runtime, then a self-swap battery — zero downtime
→Built for repairs, not replacement — modular joints and hands
→Designed for upgrades, meaning this version is the worst it will ever be
Car companies spent a century perfecting mass production.
Hyundai just pointed that same machine at building workers instead of vehicles.
If a car company can manufacture humanoid labor at automotive scale, "dealership pricing" for a robot stops being a joke and starts being a supply chain question — one Hyundai already knows how to solve.
What happens to warehouse and factory wages once the robot costs less than the car it's building?
Marc Edge retweeted
WALL-E now exists outside the movie.
Droid builder Matt Hobbs built a fully functional, remote-controlled version.
Tank treads, articulated head, expressive eyes.
He rolled it straight into Adam Savage's workshop.
→What used to need a visual effects team now needs a control system and patience
→Character design is turning into a robotics skill
→The gap between "movie robot" and "real robot" is shrinking faster than most people are watching
Every movement is puppeteered live through the Kyber Control System.
It's a rig hobbyist builders use to bring fictional characters to life in real time.
No motion capture.
No CGI.
Just servos, tracks, and a controller translating a Pixar character into physical motion.
This is what the "robots are still years away" conversation keeps missing.
The hardware side is already solving problems people assumed only studios could touch — expression, personality, believable motion.
On a garage budget instead of a VFX budget.
The people combining mechanical design with control systems today are building a skill set that barely had a market not long ago.
Watching a fictional trash-compactor robot roll into a garage and feel alive is a preview of where robotics is headed — and who's positioned to build it.
Marc Edge retweeted
🚨GPT 5.6 Pro vs Fable 5
this is the first real competition that cover game logic , ui , 3d aspects
Fable 5 mogs 5.6 pro in every aspects watch video same prompt different results , no external assets used
Thanks to @Gc_qube for the prompt and test , follow him everyone😾
Marc Edge retweeted
9-5 employees are quietly adding $10,000+/month with AI Publishing.
Without their boss knowing.
I've compiled all my Claude prompts and systems into a 53-page guide.
Like + comment "Boss" and I'll DM you my step-by-step guide for free.
You must be following me to receive the DM.
For only 24 hours.
Marc Edge retweeted
Very soon, people will stop calling it "AI film" and just call it film 🎬
This millions of views film is Made SOLO in just 3 days with “Buzzy Agentic Canvas”
You can steal the entire workflow and canvas below to get your optimistic film
Episode 2 drops next week
Marc Edge retweeted
the engineer who built Claude Code just dropped a 28-minute video on how to write prompts that actually work
I've seen $300 courses that don't cover what he shows in the first 10 minutes
CLAUDE.md files, memory shortcuts, parallel sessions, prompting patterns
all in one video and completely free
after watching this, the next step is agents
I wrote a full guide on how to build one yourself with Claude Code
article below
Marc Edge retweeted
Anthropic and OpenAI are both telling engineers to write loops.
Not prompts.
Not agents.
Loops.
That is not a coincidence.
When the two most important AI labs on the planet independently converge on the same pattern — that is a signal worth paying attention to.
Most engineers are still thinking in terms of single calls.
Input → model → output.
The engineers winning in 2026 think in cycles.
Output becomes input. The model evaluates its own work. The loop runs until the result is right.
This is the complete breakdown of what loops are, why they matter, and how to build them ↓
Marc Edge retweeted
A teenager in the United States started publishing software at 14 in 1998, built the entire online infrastructure for the Occupy Wall Street movement in 2011, joined Google as a software engineer, quit in 2018, and then spent five years writing a C library that does something the entire industry said was impossible.
Then she combined it with llama.cpp and shipped the easiest way on the planet to run a large language model on any computer.
Her name is Justine Tunney.
Here is the story, because almost nobody outside the low level systems world knows what one engineer has built.
Justine was born in 1984. She started writing and publishing software at 14, back when distribution meant uploading binaries to BBS systems and chat networks. She picked up the handle jart, which she still uses on GitHub today. She did the work most teenagers her age were not doing. She read the systems programming literature. She studied compilers. She fell in love with C.
In July 2011 she registered the @occupywallst Twitter handle and the occupywallst dot org domain. Within weeks the protest movement that began in Zuccotti Park in New York had become a global phenomenon, and her infrastructure was the digital backbone of the entire thing. She handled the social media, the website, the donations, the coordination. She built the platform that pushed the movement to reach millions.
After Occupy she joined Google as a software engineer. She worked on TensorBoard, the visualization tool for TensorFlow, and on site reliability for Google infrastructure. She stayed for years. Then in 2018 she left Google Brain to work on a personal project.
The project was called Cosmopolitan Libc.
Cosmopolitan does something most C programmers would tell you is mathematically impossible. It lets you compile a C program once and have the resulting binary run natively on Linux, Windows, macOS, FreeBSD, OpenBSD, and NetBSD with no modification. One file. Six operating systems. No virtual machines. No interpreters. No recompilation. The technique she invented is called Actually Portable Executable.
The implications are wild. Cosmopolitan binaries violate every assumption about how operating systems load programs. They are at once a Windows PE file, a Linux ELF binary, a macOS Mach-O binary, and a shell script. The same bytes run on every platform.
For five years she worked on it mostly alone. She funded the development partly through Mozilla's MIECO program, which sponsored her work on Cosmopolitan 3.0, released on October 31, 2023.
A month later she shipped llamafile.
llamafile is what happens when you combine Cosmopolitan with llama.cpp. You take any LLM weights file in the standard GGUF format, you wrap it in Justine's binary, and you get a single file that runs on six operating systems without installation. No Python. No CUDA setup. No dependency hell. Just one file that you double click and it works.
Mozilla launched it as an official project of their innovation group on November 29, 2023. It went viral immediately. The repository, hosted at github .com/mozilla-ai/llamafile, now has 24,600 stars. The license is Apache 2.0.
Justine kept shipping. She added GPU support to Cosmopolitan, a task systems engineers thought would require rewriting the whole thing. She added dlopen support, another thing nobody else had figured out. She wrote whisperfile, a single file version of OpenAI's Whisper speech-to-text model based on the same architecture.
Her GitHub profile lists projects most engineers would consider impossible. sectorlisp, a Lisp interpreter that fits in a boot sector. blink, the tiniest x86-64-linux emulator on Earth. bestline, a teletypewriter command session library. redbean, a complete web server inside a single zip file.
A teenager who shipped software in 1998 grew up to write the C library that the entire local AI movement now runs on top of.
She did most of it alone, and most people scrolling AI Twitter cannot name her.
Marc Edge retweeted
Karpathy said something you'll regret ignoring:
"Remove yourself as the bottleneck. Maximize your leverage. Put in very few tokens, and a huge amount of stuff happens on your behalf."
Loop engineering is the exact thing that does that.
In a hand-run session, the operator handles two things:
- deciding what the agent runs next
- and checking its output before the next step
Both are manual, and both decide how far the agent gets on its own without the operator.
Loop engineering moves both steps into the system.
A core operating structure surrounds the loop, and the diagram below depicts it.
- A schedule decides what to run
- Loop is the maker that produces the work
- A separate checker agent grades the output
- A file on disk holds the state they both read.
The loop runs until either done, max iterations, or an exhausted budget.
Here are some practical engineering considerations:
1) A model grading its own output justifies what it already did instead of catching where it failed.
That's why a separate checker's findings return to the maker as the next instruction. And the cycle repeats until the checker finds nothing left to fix.
2) A loop with no stop condition burns tokens, and the cost climbs fast once sub-agents and long runs add up.
That's why the exit must be set before the loop runs, not while it is running.
A simple exit could be:
↳ fix only the major issues, run one final pass, and stop after two loops, with "all tests pass and lint clean" as the rule that ends it.
3) State has to live on disk, not in context.
The model forgets everything between runs, so an MD file or a knowledge graph holds what is done and what is still open.
Each run reads it and writes back to it, which lets a loop pick up again after days.
4) The lower the verification bar, the safer the loop.
Boring, repetitive checks like a stale version string or a missing test are trivial to verify, so a loop runs them with little risk while the operator is away.
Judgment-heavy work is loopable too, but only as far as the checker can confirm the result.
Let's look at how an unattended loop fails in two ways.
1) It reports done when nothing is actually verified.
The separate checker exists to prevent it, but it merges code faster than anyone reads it, so over weeks, the team stops understanding its own codebase while every check stays green.
Green tests say the code passed the tests, not that anyone knows what shipped. Someone still has to read what the loop merges.
2) The checker keeps a running loop honest, but it only catches failures inside a run.
The harness around the loop, like the prompts, tools, and checks wrapped around the model, still drifts and breaks in production as models change.
That repair loop is usually run by hand based on observability traces.
My co-founder wrote a detailed walkthrough (with code) on making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it cannot recur.
Read it below.
