I Handed My 3D Printer to an AI for One Evening. It Missed Three Times - and That's the Best Part

The camera inside the printer showed an empty bed, the nozzle parked in the corner, and the first layer got going. I look at my phone and realize: no plastic is coming out. The nozzle is hot, the head is moving, and nothing is following it. The printer was honestly printing air.

That was neither the first nor the last time things went sideways that evening. Which is exactly why I want to tell you about it - not the glossy result, but how it actually came together.

Where it started

I have a Bambu Lab P1S and Claude Code on my Mac. The idea was cheeky: let the AI run the printer completely. Not “generate me an STL,” but really - look at the bed through the camera, slice a model, load the right plastic, start the print, watch it. And along the way handle the stuff I always hated doing by hand: “print this part 3% bigger,” “change the digit on this model.”

Over the evening it grew into a living system: two sets of tools (3D modeling separate from printer control), a link to the P1S over the local network, camera snapshots, slicing from the command line.

The very first thing the system did was run itself on something small - it designed a keychain tag with my initials from scratch, sliced it, and got it print-ready. Silly on the surface, but it tested the whole chain at once: from “I want this thing” to a bed-ready file, without a single mouse click. The chain worked. And then the real adventures began - and the interesting bit is exactly where I tripped.

Pitfall #1: printing into thin air

First run, and the printer set off printing with no plastic. I caught it with my eyes before my head caught up: on the camera the head is moving, but there’s no trail behind it.

The cause was dumb and elegant at once. When you slice a file on the fly, with no tie to the AMS, the job has no “feed filament from the tray” command. The printer assumes plastic is already in the nozzle and calmly draws nothing. The standard library “load filament” call was sending tray code 255 - which means “external spool, none.” I had to dig into the protocol and send the actual tray number. After that the printer honestly pulled the brown PLA from the third slot, heated up, purged the nozzle - and set off with plastic this time.

The lesson I burned into memory: check not “command accepted,” but “there is actually filament in the nozzle.”

Pitfall #2: the font I guessed three times

I have a model of a university building with “Graduation 2026” engraved on the roof. I wanted to change the year - one digit, surely.

Turned out to be a detective story. The model is a baked STL, no “just edit the text.” At first I was analyzing the wrong roof slope entirely: a render doesn’t tell you which side you’re looking at, and I spent two hours puzzling over geometry that wasn’t there. The breakthrough was an “x-ray” - a depth map where the text reads like a photo, with exact coordinates for every letter.

Then, the font. My first pick was by eye, and the seven came out wrong. Miss. Then an algorithm compared the engraving against every font on the system and confidently said “Didot Bold, stretched.” Also a miss - the stretch was an optical illusion from the roof’s tilt, not real. And only when I thought to dig into the original Bambu Studio project did I find the truth: it said “Noto Sans Batak” - a font with no Latin letters at all, so the program had quietly substituted a fallback, the Chinese Songti. That’s what everything was printed in.

Even once the font was right, I caught myself twice on the small stuff: the seven sat a touch below its neighbors, then a touch above. I measured it with a ruler right on the model until it landed dead on. I also worked out why the seven “looks off”: in this font it is naturally a bit shorter than the two - that’s the design, not a mistake.

Pitfall #3: the corners curled up

The print is running, I’m watching the stream on my phone - and I see the ends of the long buildings lifting off the bed. My first thought was “the bed overheated.”

And here is where I caught myself in a wrong guess. I checked the Bambu docs and common practice: a “too-hot bed” in the PLA range is a myth. 55 degrees is exactly right; overheating gives you a bulging bottom, not lifted edges. Curled corners are shrinkage plus poor adhesion. In my slice profile the brim was simply off, so the long thin edges had nothing holding them down. Plus cooling at full blast from the first layers sped up the shrinkage.

Out of this came maybe the most useful thing all evening: a database of common print defects and a check of the model BEFORE it prints. Now the system looks at the part itself and says “big flat footprint - add a brim,” “steep overhang - needs supports,” “tall part on a narrow base - it’ll tip.” Before the failure, not after.

And then I gave it eyes

I caught that warping on the stream by chance - I just happened to be watching. And I thought: why should “just watching” be my job? Let the system watch.

Now, every five minutes during a print, it grabs a camera frame and asks a vision model: is everything fine, or is it already a disaster - a spaghetti tangle, a detached part, a blob on the nozzle? If it’s a failure, I get a message with a photo, before the printer itself even realizes it’s printing into the void. You used to learn about a failed print an hour later, when the whole bed is noodles. Now it’s almost immediate.

I’ll be honest about the limit: a gross failure like spaghetti it spots confidently, but mild warping, like on my buildings, it called “clean.” So the eyes are a catastrophe net, not a replacement for the pre-print check. Keep both: “think ahead” and “keep an eye as you go.”

The moment I was genuinely floored

You know the moment it hit me this wasn’t a toy? I said, in words: “check with the camera that the bed is clear, and start the print.” And the printer in the other room hummed to life. On its own. Heated up, licked the bed, pulled plastic, and set off - while I sat there with my phone watching it like a magic trick.

Before that I’d opened the slicer with a mouse twenty times, dragged the model around the bed, ticked boxes. And here - one sentence, and a machine in the next room makes a physical object. I genuinely sat there grinning. Not because “the AI is smart,” but because for the first time the distance between “I want this part” and “the part is on the bed” collapsed to almost nothing.

And the funny thing? Every time something broke - air instead of plastic, a crooked seven, a lifted corner - I didn’t get angry, I got hooked. Because you could see it: here’s the problem, here’s the cause, here’s the rule, and next time it won’t happen. It’s like taming something alive.

How it all became commands (about MCP)

To keep it from being a pile of scattered scripts, I gathered everything into two sets of tools - what’s called MCP servers. I split them on purpose: one handles only 3D models (create, measure, stretch, add text, cut, run a generative calc, check before printing), the other only the printer (status, camera, load plastic, slice, start, stop, turn on the stream).

The point is simple: now the printer and the modeling aren’t programs you have to climb into, they’re plain commands the assistant understands. “Show me the camera.” “Check the model for problems.” “Run a generative calc for a bracket under this load.” “Start the print from the brown slot.” I split them into two servers deliberately - so working on shape and working on hardware don’t get tangled, the way a screwdriver and a drill live in separate drawers.

Sounds dull and technical, but this is exactly where the magic lives. Build the tools right once, and after that you just talk.

A private camera nobody can find

A separate story is the camera stream. I wanted to watch the print from my phone anywhere, but with access only for me, and with that door impossible to even feel for.

We did it through my own server, not a public service. A random hostname under a shared certificate, so it never shows up in search logs. Entry only with a personal certificate on the device - without it the server drops the connection before any password, so there’s nothing to brute force. A direct hit on the server address just gets cut off. Paranoid? Maybe. But a camera inside my home is exactly the case where paranoia belongs.

And the finale it was all for

In one clip I saw a chair where the load-bearing “skeleton” was designed generatively: you set where the mounts and the load are, and a strength calc strips away all the material that isn’t working. What’s left is an organic, bone-like structure. I wanted the same.

Now the system can do it. You set the envelope, the support points and the load - and the solver returns a truss-like part where material sits only where it actually works. The first bracket is already sitting print-ready.

The first digit - three hours. The next three - a minute each

This is probably the main thing I understood that evening.

One swap, the six to a seven, took me almost three hours. Not because the task is hard, but because I was, in effect, teaching the system. We went through a pile of sevens - wrong font, wrong height, sitting a bit below the other digits, then a bit above. I ran it a dozen times, catching every little thing with a ruler. All those misses are saved; you could lay them side by side - a whole gallery of wrong sevens until the right one was born.

And then I just said: “now make 2028, 2029 and 2030.” And here’s where the thing it was all for happened. The rules are already written, the tools built, the font and depth dialed in - and three new years came out in a minute or two each. Correct on the first try. Not a single iteration.

So I first spent hours teaching the system to do ONE thing well. After that it snaps through every similar task instantly. The first part pays for the whole road; the rest ride it for free.

And it turned out not to be a one-off

Then came ordinary requests - and this is where it showed the evening wasn’t wasted.

I wanted to print those same buildings for other years. I just said: make 2028, 2029, 2030. A couple of minutes later all three were ready - with the same dialed-in depth and font I’d fussed over on the seven.

Then a great story about a mistake surfaced - and about how fast it gets fixed now. It turned out the years were built on the WRONG building model: an old draft instead of the final version I’d actually sent to the university. I said so - and the system dug into my email, found that exact German letter with the attachment, identified the right file (with the open arch passage and the widened slot for a photo), checked the geometry, and re-applied all four years to the correct model. Minutes. The mistake was fixed almost as fast as it appeared.

And here is how that thread ended in the real world - a frame from the printer’s camera, not a render. The correct model from the email, the fixed digits, a brim around every building, corners pressed flat, the years readable on the roofs. No three-hour struggle: found, fixed, queued - and it printed clean on the first run, because every past mistake already lives in the rules.

Buildings for four years, a model fixed on the fly - and all of it without the three-hour struggle now. You teach it once, then you just use it.

The stand that is still torturing us

And then I asked for a laptop stand - and the easy life ended right there.

It started briskly. I named the model, Dell Latitude 5430, said “foldable and light” - and a few minutes later had a flat-pack of four parts: two lacy side plates computed for the real load, two crossbars, everything snaps together in fifteen seconds, weighs about 55 grams. On paper, a win.

I rejected it. “Foldable” in my head meant real hinges, not “take it apart into sticks and stack them”: open it - it stands, fold it - a flat slab goes into the bag. One object, not a single detachable part. I said: redo it.

And that’s where a saga began that is still running.

First came the bone shapes - a skeleton of fused branches, beautiful from some angles and useless as a mechanism: a hinge blobbed out of droplets does not turn. Then Voronoi carving - warmer, cells in a gradient like designer pieces have. Then the night when the generator stamped out a dozen “variants” with no checks and kept sending them to my Telegram. In the morning I wrote back honestly: this is garbage. You can’t see how they fold, half of them can’t even hold a laptop, and printed they would never move.

After that roasting I rebuilt the process - and this, I think, is the most interesting part. An autonomous loop now runs at night: every few minutes a fresh session reads a state file, studies real folding stands with high ratings, improves the generator and builds a candidate. And then comes the key word - it PROVES it. The fold is verified geometrically: a rotation about a real hinge axis, zero part intersections in both poses, the laptop’s centre of mass strictly between the supports, the load going into a hard stop instead of a thin pin. Then a separate design judge decides whether it’s even worth showing. Garbage doesn’t reach my phone anymore.

In its first night the loop clocked thirteen iterations. Here is the morning’s best: an openwork deck, a kickstand leg on a hinge printed already assembled, a cam lock that the laptop’s own weight presses shut. 111 grams.

Done? Not yet. I’m still not sure the cam holds a kilo and a half, I don’t like the narrow stance, and this morning I sent it all back for rework again - this time armed with hinge and latch catalogs that three parallel agents are compiling. But compare the two ends: from “a kit of sticks” to an object that proves with numbers that it folds and holds.

Suffering? Absolutely. But this is exactly how the system learns - every roasting turns into a new validation rule. And I’m almost sure the next folding thing it will get right on the first try. We’ll see.

What I took away

The most valuable thing that evening wasn’t what worked on the first try, it was what did NOT. Printing air, three font misses, curled corners, a wrong guess about overheating. Each mistake turned into a rule the system now remembers for me.

And here’s the honest bit. Changing one digit on a model by hand is a five-minute job, less even. If you count only that task, my whole song and dance with the system makes no sense at all. I spent an evening where a couple of clicks would have done.

But I wasn’t buying a five-minute shortcut. I was building not a “digit swap” but a system that can now make almost anything: design it, run a strength calc, slice it, load plastic, start the print, keep an eye on it, and warn me where I’m about to mess up. Invest once - and after that it works on any object, not on one inscription.

And yes, honestly: it’s still raw. Alpha, maybe earlier than alpha. How well it will handle complex things is still to be tested and tested again. The first batch came out with curled corners, the settings weren’t right; but the defect database is already built, the profile fixed, and the next batch came out flat and clean - the photo with the finished buildings is above. Not perfect on the first try - but fast to right.

And you know what? That moment - when you’re holding a raw, alive, just-built thing that already does something and is about to learn more - is the real kick. Not a finished, glossy product, but this stage, when it’s all just being born. I genuinely love it.

I’m still not sure the chair from that clip would hold my 80 kilograms. And I’m not sure my system won’t trip over something new tomorrow. But the folding laptop stand the machine designed, I already want to hold in my hands - and that feeling matters more than any guarantee.