Tim Daugs

NOBODY OPENED BLENDER TO MAKE THIS. THE MODEL TYPED IT. a car falling through a pink cloud deck at altitude, a starfighter cutting the sky behind it, mountains burning gold on the horizon. GPT-5.6 drives Blender through MCP. it never touches the interface. it writes python and runs it: → volumetric clouds, built as code → shaders and emission, written not clicked → camera roll, lighting, the whole grade and the clouds are the flex, not the car. volumetric atmosphere that reads as depth instead of pink soup is what artists lose entire weekends to. it just wrote it. what it cannot do is look. it built this frame blind: → you screenshot the render → you tell it the highlights are blowing out → it fixes, you screenshot again for twenty years the price of a shot like this was learning the software. that price is now zero, and nobody's priced in what that means yet.

FABLE 5 AND GPT-5.6 BUILT A PLAYABLE MECH SHOOTER. THEN THE FIRST BUILDING THEY PLACED BROKE THE CAMERA. lock-on combat, hardpoints, ammo counters, kill feed, a working score. all systems, all code, and code is the part these models actually own now. then someone dropped a box in to fake a ruined building. and the whole thing exposed itself. in a lock-on shooter you're almost never looking where you're driving. camera's tracking the target, chassis is going sideways. so the mech snags the building. the camera snags the building. the fight stops being a fight. the fix isn't a better model. it's the oldest lesson in level design: cover has to be destructible, or it has to not be there. the model can hand you a working game in an afternoon. it cannot tell you the level fights the camera. you find that out by playing it.

@explosss1ve It looks incredible bro

YOU DON'T NEED TO KNOW BLENDER TO MAKE THIS ANYMORE. GPT-5.6 drives it through MCP. you just describe the shot. a chrome figure carving a wave off an accretion disk. filaments of plasma raking across the frame. a car catching the same light on its way into the vortex. this is a viewport, not a render farm. the model never touched a menu. MCP hands it a socket into Blender, it writes python against bpy, it builds the emission shader, places the volumetrics, sets the camera roll. the hard part was never the picture. it was the ten thousand hotkeys standing between you and the picture. that toll booth just closed. it still can't see what it made unless you show it. you screenshot, you say the plasma's washing out the left third, it fixes, you screenshot again. the skill stopped being the software. the skill is now knowing what a good frame looks like and being able to say it out loud.

FABLE 5 BUILT A SURVIVAL SIM WITH READABLE OCEAN WATER AND A FULL SEASON/TEMPERATURE HUD IN A COUPLE OF HOURS. not a screenshot mockup. a running scene. reflections on the water, a half-drowned timber tower, a clock ticking, temperature at 0.00, day one of spring up in the corner. the model wrote the systems layer, and that's the part that used to eat a weekend. the water shader, the HUD state, the day/season clock, the swim controller, all of it is code. and code is exactly what it's good at now. the water surface is the tell. getting an ocean plane to reflect and catch light so it reads as water, not a blue floor, used to be a tutorial rabbit hole. here it just showed up. what it can't hand you is whether swimming toward that tower feels like anything. drift, weight, the small dread of cold open water. that's still tuning, and tuning is still human. the barrier to standing a world like this up basically fell off. deciding whether it's worth being in is the part that didn't move.

YOUR AGENT'S BENCHMARK SCORE MIGHT BE MEASURING WHERE IT SAVES FILES, NOT HOW SMART IT IS. a frozen open model scored 0% on a hard legal agent benchmark. weights untouched, they let a loop rewrite only the harness around it. it ended up matching Sonnet 4.6 at a fraction of the cost per task. the model was reasoning fine the whole time. it just kept saving the deliverable under the wrong name, in the wrong folder, or not at all. the judge only counts the file when it lands exactly right. the 0% wasn't a reasoning gap. it was a wrapper bug. the fix that beat every prompt tweak: a step that drops the output exactly where the grader looks. no extra model tokens. same model, same tasks, five harnesses spread from 3.5% to 80.1%. the wrapper was the variable, not the intelligence. you can't tell if the model failed until the harness around it stops failing first.

SOMEBODY BUILT A ROBOT ARM TO TAP PHONE SCREENS. THE ARM IS THE TELL. a gantry, a stylus, a row of phones scrolling short video forever. it looks like the peak of the phone-farm meme. it's the opposite. a single line of adb does every swipe on that rack in software. input swipe, no motors, no rail, no 3d-printed finger dragging across glass. so why build the machine? because a software tap is easy to flag, and a physical finger is harder to catch. the arm isn't there to save labor. it's there to look human to something watching. that's the whole line. the legit version of this never needs a finger. it removes the tapping, keeps the accounts real, and the phones just sit there doing what a person approved. the moment you're engineering a robot to fake a human touch, you've stopped building a content op and started building the thing platforms hire whole teams to kill. the phones were never the hard part. pretending a machine is a person is.

a wall of phones, a few laptops, and nobody tapping a single screen. the whole operation is a script that fits on one page. it looks like a click farm. it's closer to the opposite. a click farm needs hands. someone tapping, swiping, babysitting each phone. this room replaced the hands with code. adb finds every phone on the wall. one script installs, runs, and records across all of them at once. the guys at the laptops aren't tapping anything. they're deciding what the script does next. that's the whole shift. the phones aren't the product. the wall just looks impressive. the product is the one page of code that makes fifty screens move in parallel while nobody touches them. the quotable version: the phones were never the hard part. not touching them is. a person taps one phone at a time and gets bored by phone six. a script runs the whole wall and never needs lunch. that gap is the entire business. wrote up how a room like this actually runs, the script and the economics and where it quietly breaks, in the article below.

a shelf of screenless phones running 24/7, each one puppeting a woman who was never real. that's the "AI influencer farm" everyone keeps posting about. honestly, the tech is the boring part. one model writes her personality and answers the DMs. another builds a face that stays consistent. a video model makes the photos move. an editor cuts it for tiktok. keeping the same face and voice across months used to be the hard bit. that's basically solved now too. so building the character was never the moat. the whole thing comes down to one move: manufacture a person who doesn't exist, then charge strangers to feel close to her. and the part nobody screenshots is what happens after. the buyer isn't paying for photos, he's paying for the belief that someone's there. the day that belief cracks, the whole thing is worthless, and nothing about the tech can stop that crack from coming. the market floods too, because if a cheap shelf of phones spins up a thousand personas, so can everyone, and attention doesn't stretch to cover them. strip the hype and it's not really a content business. it's a loneliness tax with an AI face on it. and that holds right up until the people paying realize there was never anyone on the other end. the tools are genuinely impressive. what they're aimed at here is the part worth arguing about.

a rack of used phones on a laptop does the exact job companies rent from the cloud for thousands a month. that stack is a device farm. one python script runs all of it. adb finds every connected phone, installs the app on all of them at once, runs the tests, records each screen. ffmpeg stitches the recordings into a single report showing how the app behaves per device. the cloud version bills by the minute. a regression run across 30 phones lands around $15, and if you run it on every push, that's thousands a month with no end date. the shelf flips it. 30 used phones near $60 each, a powered hub, a mini-pc. roughly $2,600 once, then basically electricity. with active ci it clears its own cost in about a month. after that the cloud keeps charging and the shelf just keeps running. it also eats the manual grind. a QA engineer plugging in, installing, poking, recording, thirty times over, was a full day. now it's a few minutes and a video report. the reason this beats the usual "hack" is that there's nothing to ban. it's saved hours and bugs caught before users see them. real work with a real invoice behind it. owning the hardware is the whole edge. everyone else is renting the same thing by the minute and calling it convenient.

50 phones on a rack, and the whole edge is that he owns them while everyone else rents from the cloud. app testing is a grind nobody wants. every release has to run on dozens of real devices. works on one, crashes on another, and catching that by hand eats a full day. so the fix is a fleet. a room of phones wired to one machine, running the boring part on repeat. the pipeline is clean: → install the app on every phone at once → run the tests in parallel → record video from each screen → stitch it all into one report with ffmpeg that part is real engineering, not a trick. the actual move is the economics underneath it. cloud device farms bill by the minute. AWS runs about $0.17 a device-minute, so a 5-minute pass on 30 phones is ~$25 a run. do that a few times a day and it's thousands a month, forever. a rack flips the shape: → pay once for used phones and a hub → run for years on basically electricity → every job after break-even is close to pure margin a 30-device fleet clears its own cost against the cloud in weeks, not years. here's the honest half nobody frames right. a testing farm is not passive income. someone writes the tests. someone fixes the flow when a vendor's android update breaks it. someone talks to the client. the agent runs the grind, not the business. but strip the noise and the real lesson holds: when compute gets cheap enough to own, renting it forever stops making sense. the edge was never the automation. it's the hardware nobody else bothered to buy.

FABLE 5 BUILT AN INTERACTIVE VOLCANO SIMULATION IN THREE.JS FROM A PROMPT. a volcanic island, ocean rendering, lava behavior, ui controls, a real-time structure. all wired together and running in a browser. the demo is cool. the direction under it is the actual story. this is the shape of scientific visualization getting cheap. a geophysicist explaining magma flow. a teacher showing why an island forms. a researcher poking at a system instead of reading a static diagram of it. that stuff used to need a dev team and a grant. now it starts from a sentence. worth being straight though. "lava behavior" in a three.js toy is a visual approximation, not real fluid dynamics or a validated physics model. it looks right. it isn't a simulation a scientist would publish from. the gap between "looks like lava" and "behaves like lava" is the entire field of computational geophysics. a prompt doesn't close that. but for teaching and intuition, looks-right is often enough. the win here isn't accuracy. it's that anyone can now spin up an interactive model of a physical system to point at and explore. we're about to get a wave of visualizations that make hard things clickable. some will be wrong. the good ones will teach more than a textbook chapter.

most 2D games fake the wind. this one, built with fable 5, actually simulates it into the animation. there's a full wind system here. strength, gusts, direction, all wired into the skeletal rig so leaves and cloth react in real time. that's the tell of someone who knows what makes a 2D game feel alive. sprites and a sword loop are the easy part. anyone can get a character swinging a weapon. what separates "asset flip" from "a place you're in" is the stuff you don't consciously notice. wind bending the grass. cloth catching a gust. a physics layer talking to the animation instead of sitting beside it. the ordering is the interesting tell too. attack animations first, then environment physics reacting live. feel before content. straight version though: a clip can't show the one thing that decides it, how the glaive feels to swing. hitstop, recovery, weight. that's runtime, and no screenshot carries it. fable 5 is writing the systems. deciding a duel should feel heavy, and that wind should sell the world, is still the person at the wheel

@outsource_ @hermesworldai bro its banger

Weekend experiment: Using Claude Fable 5 as our main dev agent on the @HermesWorldAI MMO. Verdict 👇🏻 -3 weeks-old bugs killed in one night (layer culling, terrain height clamp, corrupted tree renders) diagnosis quality is better and planning is far better. ~70% of usage was execution work Opus can handle -Used 3 Max plans (20% quota left) 😅 The unlock isn't "better model everywhere." It's Fable for root-cause + architecture + review, Opus for execution, local models for the grind. Have Fable improve your skills, workflows and plan your projects!

FABLE 5 BUILT A WALKABLE STARSHIP IN THREE.JS, THEN DEBUGGED ITSELF BY STARING AT ITS OWN SCREENSHOTS. one prompt in. a full explorable ship out. not a static scene. a place you move through: → a working cockpit you can stand in → crew quarters → a planet drifting past the real windows → dynamic lighting that reacts as you move → sleep and eat interactions wired in then the part that actually matters. it screenshotted its own render, looked at what came back, saw the framerate was wrong, and kept rewriting until the browser held a steady 60fps. read that again. the model judged its own output and iterated on it. that's the shift hiding under the demo. writing code blind is old news. what's new is the loop: → generate → look at the result → notice it's off → fix → repeat until it hits the bar that's what a real dev does all day. the model is starting to do the boring middle of it on its own. where it still ends, honestly: an "explorable demo" is not a game. no goal, no stakes, no reason to come back after two minutes of walking around. and a screenshot can't feel anything. it can't tell if moving through that ship is satisfying or floaty and dead. game feel is the whole job in a first-person space, and it's exactly the thing a still frame hides. so no, this isn't shipping to steam next week. but a self-correcting three.js starship at 60fps, from a single prompt, is not a small thing to wave off. a year ago this was a weekend for a small team. now it's a prompt and a model patient enough to fix its own mistakes. the code was never going to be the bottleneck for long. taste is. deciding what's worth building, and whether it actually feels good to play, is still the part that's yours.

AI JUST BUILT THE SKELETON OF AN OPEN-WORLD RPG FROM A FEW PROMPTS. third-person, night-lit 3d field, a pumpkin-headed character with a sword. compass with directional bearings up top. lv 1, 0/100 xp bar. a radial wheel for items and mounts. all of it out of fable 5. that's not a toy demo. that's the bones of an actual game. what fable 5 is doing here is the systems layer. the xp curve. the quest state. input handling. the wiring between "walk into marker" and "trigger dialogue." real code, and the part that used to cost a beginner weeks. what it's not doing is the rest of the iceberg. the character model, the terrain, the lighting, the sky. those come from an engine like unreal or unity and its asset pipeline, not a text prompt. "a few prompts" almost always means the logic, not the art. and a screenshot hides the one thing that decides a game: how it feels to move. camera lag, hit response, whether the controls fight you. no still frame tells you that. still. a working systems skeleton for an open-world rpg, from prompts, is a wild place to be standing. the model builds the machine now. deciding what game the machine is for is still yours.

@measure_plan threejs cooking...

you can just light things with threejs

@explosss1ve Now this is the kind of AI project I love seeing

Someone built a lego world you can fly through in a browser tab. no engine. no download. three.js and fable 5. the terrain isn't placed by hand. it's procedural. every hill, forest, and stretch of water gets generated by an algorithm instead of dragged into position block by block. voxel forests water a working minimap flight controls with speed, turn, boost runs at a vercel url you can just send someone. the split that made it work: three.js handles rendering and flight fable 5 writes the logic. terrain gen, controls, the state holding it together the model can write clean procedural code all day. what it can't do is decide the world should be lego. or that flight should feel floaty instead of tight. that call is still yours. the terrain algorithm is the honest hard part. it's the difference between "i rendered some cubes" and "this feels like a place." nail that one system, the rest is decoration. pick a dumb constraint and build a small world around it. lego. only blue. everything upside down. you'll learn more three.js in a weekend than a month of tutorials gets you.

@explosss1ve Couldn't agree more, fast feedback loops are the biggest win.

@TimDaugs Love this. The first version is almost instant now. Iteration is where the magic happens.

someone rebuilt flappy bird from a single prompt. the demo shows a neural network learning to play it. the real story is smaller, and more useful, than that. what actually got generated: → real-time physics → gravity constants → pipe spawn timing → collision detection → a playable window in under ten minutes no engine license. no drag-and-drop node editor. no boilerplate copied from a five-year-old tutorial. the framing going around is "this replaced a $200/month subscription." that part i'd slow down on. no-code game tools never charged you $200 for gravity math. they charged you for not having to think about it. the physics were always fifteen lines. what you were really buying was the hours. the setup. the not-starting-from-a-blank-file. so what got replaced isn't the tool. it's the friction between "i have an idea" and "i have a thing i can click on." for simple mechanics, that gap is basically gone now. here's the catch nobody screenshots. flappy bird is the hello world of game physics: → one player → one input → one obstacle type → one fail state it's the demo everyone reaches for precisely because it's the simplest state machine wearing a game costume. of course the model nails it. it's the easy case. the neural-net-learns-to-play layer looks impressive in a clip, but that's a solved textbook problem too. genetic algorithm plus a fitness score. it's been a github tutorial for a decade. the model didn't invent it. it recalled it. none of that makes it fake. it makes it a real signal about where the line moved. the old barrier: "can you write the physics loop." that's down. the new barrier: "do you know what to ask for, and can you tell when the output is quietly wrong." because the second you go past one enemy and one fail condition, you hit the part the prompt can't do for you: → state that spans screens → a second obstacle that interacts with the first → save data → deciding how the systems talk to each other the model writes any single piece on request. it doesn't hold the whole architecture in its head, because it doesn't know what game you're actually building. that's still you. that was always the interesting part anyway. build the flappy bird. it takes ten minutes and it's worth doing once. just don't confuse clearing the tutorial with clearing the game.