Planagonia's whole pitch is that a floor plan can be written, not just drawn — by you, or by an AI on your behalf, in a small language built to be easy to get right. We'd said that since Planagonia went live. What we hadn't done was actually test it against a second, independent AI with no connection to this project at all. So we did: two AIs, the same brief, the same camper van, zero coordination between them. Here's what comparing their two attempts taught us, and what it led us to build.
The claim we'd never actually put to the test
The idea behind Planagonia's own language is specific: it's not meant to be merely readable by an AI, the way most file formats technically are if you feed them in whole. It's meant to be a format an AI can write correctly, on the first try, from a plain description of a room — because that's the entire point of separating "what a plan looks like" (a drawing) from "what a plan is" (a small, plain-text program). We'd used it ourselves constantly. We'd documented it carefully. Neither of those is the same as watching someone with zero context reach for it cold.
The experiment: same brief, two AIs, no coordination
We picked a real, specific task — design the interior of a camper van, bed, kitchenette, storage, the works — and wrote it up as a plain brief, the kind of instructions you'd hand anyone. One attempt we did ourselves, directly. The other we handed, unmodified, to a completely separate AI system with no history with Planagonia and no way to ask us questions mid-task.
The goal was never to see which attempt was "better." It was to see where two honest, independent attempts at the same real task would snag on the same rough edges — the specific kind of gap that only shows up once a tool meets a task it wasn't specifically rehearsed for, not one you can find by rereading your own documentation.
What the comparison actually revealed
Lined up side by side, the two vans disagreed in plenty of small ways — but they converged on the same handful of missing pieces, which turned out to be more useful than any single bug report. A few of the patterns that stood out:
- A plan's own name is basically a variable. Give two pieces of furniture the same internal name by accident, and Planagonia would silently start editing the wrong one when you dragged the other — a direct consequence of treating a plan as real, structured text rather than a drawing, with all the classic hazards of source code (like reusing an identifier) that come with that choice. Both attempts eventually hit it independently, which is what convinced us it needed to be caught immediately, not eventually.
- A rule like "keep everything inside this room" is really a tree, not a list. Setting a container to hold its contents only ever checked one level down — an object nested two levels deep (an appliance inside a cabinet inside the van) had no such guarantee at all. A one-level check is an easy thing to write and an easy thing to not notice is one level short, until a real, deeply-nested layout — exactly what a camper van's cabinetry naturally produces — walks straight into it.
- Checking-while-editing isn't the same as checking. Planagonia already knew how to flag two overlapping objects that shouldn't overlap — but only while a drag was actually in progress. A plan that already had the overlap baked in, untouched since the moment it was written, was never re-examined at all. Both vans, generated in one pass rather than nudged into place by hand, exposed exactly that gap.
None of these were things a quick read of either van's code would have caught on its own — each one only became visible by comparing two independent, complete attempts at the same real task against each other.
What we built in response
Every pattern above turned directly into a feature, not just a patch:
- Validation now runs the moment any plan loads, not only while something is being dragged — so a plan generated in one shot gets exactly the same scrutiny as one built by hand, click by click.
- "Keep contents inside" now applies at every nesting depth, not just the first — an object inside a cabinet inside a van is held to the same rule as the cabinet itself.
- Duplicate names are now caught and flagged the instant they'd cause a conflict, rather than silently redirecting an edit to the wrong object.
- You can now undo a mistake — a drag gone wrong, an accidental delete — with Ctrl+Z, the way you'd expect from any editor.
- Right-clicking a piece of furniture now lets you duplicate it, instead of retyping the whole thing to add a second identical chair — including everything nested inside it, like a drawer with its own hardware, all copied together as one unit.
- Windows and doors can now be built directly into a wall, staying flush against it as you slide them along, instead of floating independently over it.
- You can now export a plan as an image (PNG or SVG), not just as code — handy for dropping a floor plan straight into a chat or a document.
A door that stays part of its own wall
Windows and doors being flush against a wall, mentioned above, is only half of a bigger idea we finished around the same time: a wall built with a door already cut into it now behaves as one real thing, not two shapes that happen to sit next to each other. Drag the wall itself and the whole assembly — wall and door together — moves as one. Drag just the door, and it slides along its own wall instead, staying exactly the width of the doorway the wall was built with, right up until it reaches either end.
A side effect: reaching what's actually hidden underneath
Both camper vans, once built, had the exact problem a real camper van has: things stacked on top of each other. A cabinet with a sink inset into it. A shelf sitting flush over a water tank. Once one object is completely covered by another, clicking on it used to be simply impossible — whichever shape painted last always won every click, with no way to reach anything underneath it, and no way to even tell something else was there. We call the fix click-cycling: click once and you get whatever's on top, exactly as before; click again at that same spot and you step to the next thing underneath it, one click at a time, wrapping back to the top once you've gone all the way through. Hovering shows a small floating label naming everything stacked at that point, so you're never left guessing what's actually there. Right-click still gets you a full menu, now including Bring to Front and Send to Back, for when you want to actually change which one paints on top for good, not just reach it for a moment.
Labels that used to overlap now nudge apart on their own
A label set to always show — a room's name, a piece of furniture's dimensions — used to render exactly where its own shape sits, even if that meant landing squarely on top of a neighbor's label. Two adjacent, similarly-sized pieces of furniture (a bed and a desk, in one of the camper van tests) reliably produced exactly this. Planagonia now measures every always-visible label's actual rendered size and, whenever two of them genuinely overlap, nudges both apart along whichever direction moves them the least — small and automatic, and it only ever kicks in when there's a real conflict to resolve in the first place.
A couple of smaller things came out of the same stretch of testing: the app's header now links straight back to the main Planagonia site, where before there was no way back to the homepage without editing the URL by hand, and every page across the site — the app included — finally got a proper favicon instead of a generic icon in the browser tab.
This kind of test — handing the same real task to a second, independent AI and comparing what comes back — is staying part of how we check Planagonia going forward, alongside building it. A tool meant to be trusted with a real decision should be able to survive someone actually putting it to work on one. Thanks for reading, and for trying something this new.