How I Ended Up With a 28" Bowl of Tufted Ramen

I wanted to try making 3D fiber foods, and I decided the first one should be a bowl of ramen. Not a flat ramen rug, which is the obvious version and the one you've probably already seen a hundred of. I wanted the actual thing: separate ingredients, built individually, assembled into a physical bowl you could look down into. Eggs. Chashu. Nori. Naruto. Green onion. Noodles. Broth. A bowl to hold all of it.

I got there. The finished bowl is about 28 by 28 by 12 inches. That was not the plan. There was, arguably, never a plan, which is sort of the whole point of this post.

Building the pantry

The appeal of doing it as separate parts is that each ingredient gets to be its own little tufting problem. An egg is not a nori is not a scallion. They want different pile heights, different materials, different construction entirely.

So I started making ingredients the way you'd stock a pantry, one at a time, not really thinking about the finished dish yet.

The egg halves are tufted, cream white with the soft yellow center. The chashu is its own tufted piece. The naruto is the fun one, a white disc with the pink spiral swirled into it, which reads instantly as fish cake to anyone who's ever eaten ramen and reads as nothing at all to everyone else. The nori is long, shaggy, dark green pile, deliberately textured so it looks like a limp sheet of seaweed instead of a rug.

The green onions are flat tufted strips, folded lengthwise and sewn into rings, so they're actually dimensional little tubes instead of drawn-on lines. The noodles are tufted too, but shaped into long rounded coils rather than left flat, so they sit in the bowl as rounded noodle forms instead of reading as stripes on a floor. And under everything there's a tufted broth lining, plus the bowl itself, which has tufted exterior walls over a wood skeleton.

I used AI a lot through this. Not to make anything, obviously, wool is still extremely a hands problem, but to brainstorm. Shapes, proportions, what material wants to do what, rough dimensions for each ingredient so they'd all agree with each other. It's genuinely good at that. You can think out loud and get a reasonable answer back fast.

Which is where the trouble started, though it didn't look like trouble at the time.

The nori incident

Early on, we'd been talking through dimensions, and I made the nori about a foot long.

One foot. On a screen, in a chat window, next to a bunch of other numbers, one foot is an unremarkable measurement. It's a ruler. It's a sub sandwich. Nobody reads "12 inches" and flinches.

Then you actually tuft a one-foot piece of seaweed and cut it out and hold it up.

That is a large piece of seaweed. That is a piece of seaweed with presence. And the thing is, I saw that, and I registered that it was big, and I did not stop.

I want to be honest about the failure here because it's the interesting part. The mistake wasn't the nori. The mistake was what I did after the nori, which was: keep going.

One reasonable step at a time

Here's how the whole thing actually escalated, and every link in this chain felt completely sensible while I was standing in it.

The nori already existed, at a foot long. So the eggs needed to look right next to the nori, which meant the eggs got sized up to match. Then the chashu had to sit believably next to the eggs, so it grew too. The naruto had to work with the chashu. The green onions had to make sense scattered over all of it. And once I had a foot of nori and eggs to match and chashu to match those and a fish cake scaled to the chashu and onions scaled to everything, all of that had to go into a bowl, and the bowl had to be big enough to hold it.

At no point did I decide to make an enormous bowl of ramen. I never had that thought. Every single component was a locally correct response to the components that already existed. It was reasonable all the way down. By the time I stepped back and looked at the whole system, the scale wasn't a decision I could make anymore. It was a constraint I'd already inherited from myself.

Starting over meant throwing out a real pile of finished tufting, all of which was fine work, none of which was wrong on its own terms. Continuing meant building a genuinely ridiculous bowl.

I continued. Obviously I continued.

The part where this is about AI, a little

I don't want to oversell this, because the tidy version of this story is a lie. The AI was not sitting there feeding me absurd answers while I nodded along. Most of the individual suggestions were fine. Reasonable in isolation, or reasonable relative to the constraints we'd already established. The arithmetic was correct. The problem is that nobody in this loop, me or the model, was consistently zooming out to check the entire physical system against reality. We were both answering the question in front of us.

If you've built anything with AI, this should feel familiar. A model will happily give you a clean function, correctly implement the feature you asked for, do the math right, and solve exactly the narrow problem you handed it, while the larger premise is quietly wrong. The function is good. The feature works. The architecture is nonsense. Nothing in the local output tells you that, because locally, nothing is wrong.

So verification can't just be "is this output internally correct." You also have to verify the model of the problem. Does this thing belong here at all. Are the assumptions from three steps ago still true. Are we optimizing the right number. Does this measurement mean diameter or circumference. Am I, right now, tufting a one-foot piece of seaweed.

That diameter-versus-circumference one isn't hypothetical, incidentally. There was some genuine confusion about exactly that while I was working out the bowl, and it's the same lesson wearing a different hat. Perfectly correct arithmetic is worthless if you're computing the wrong quantity. A number can be right and mean nothing.

And to be clear, I'm not letting myself off the hook and blaming the robot. The human is half of this feedback loop. I accepted plausible answers and kept moving, because plausible answers are comfortable and moving forward feels like progress. The failure mode that's actually worth naming isn't "the AI was dumb." It's the interaction: a system that faithfully answers each question, plus a person who keeps building without ever validating the whole.

Wool has a much worse undo

The reason this landed as hard as it did is that fiber work has a brutal feedback loop compared to software.

In code I can compile, run the tests, read the diff, revert, regenerate, delete the whole implementation and start over before lunch. The cost of being wrong is usually minutes.

To find out a tufted ingredient is too big, I first have to design it, project or draw it onto the tufting cloth, tuft the entire thing, glue and back it, cut it out, and finish the edges. Only then do I get to hold it in my hands and discover it's enormous. Wool has a considerably worse undo function. There's no ctrl-z on a yard of finished pile. There's just a decision about whether the sunk cost is worth eating.

That's what made the verification problem so physical here. In software the gap between "wrong assumption" and "consequence" can be small enough to ignore. In fiber, the gap is a full afternoon of tufting, which is exactly long enough to commit you to the mistake.

The bowl itself is a wood skeleton, a plywood ring with vertical posts, wrapped in a black tufted lining on the inside and the cream tufted wall on the outside. Building the frame is when the number stopped being abstract. You can hand-wave a big tufted egg. You cannot hand-wave a plywood ring that no longer fits comfortably on the workbench.

The mistake made it better

The scaling accident made the piece better, which is inconvenient for anyone hoping this ends in a tidy lesson about measuring twice.

I would never have deliberately sat down to design a 28-inch bowl of ramen. It's too much. If I'd verified the scale up front like a responsible person, I'd have built something sane and correct and a lot less interesting. Following the existing scale instead of fighting it pushed the whole thing somewhere stranger and more sculptural than I'd have chosen on purpose. It stopped being a ramen-themed rug and turned into an actual mixed-media object.

And the size is what forced the construction to get honest. Because it's big, each part had to solve its own problem instead of everything being flattened into one tufted plane. It's mostly tufting throughout, but the tufting had to do different things: flat graphic pile for the eggs, chashu, and naruto, long shaggy pile for the nori, strips folded and sewn into rings for the scallions, coils shaped into rounded forms for the noodles. Then plywood for the skeleton, because nothing soft was going to hold that shape.

Above is roughly where it is now, 28 by 28 by 12 inches of it. My hand's in there for scale in one of these and it is not reassuring.

Verification still matters. I genuinely should have stepped back and sanity-checked the scale before the nori set the pace for everything else, and the fact that it worked out doesn't retroactively make skipping that step smart. The thing worth carrying over to code is narrow: know when you're trusting a stack of locally correct answers without ever validating the system they add up to. That's the failure, and it happens to seaweed and software about equally.

But also, sometimes you've already made the one-foot nori. And once you've made the one-foot nori, you might as well build the fucking bowl.