I've been working on a project called Furnish for the Kane CLI Hackathon.
The idea was simple: what if you could describe the home you want, get an actual editable floor plan, make changes with AI, and walk through the building in 3D before it's even built?
But I didn't want to stop at generating a nice-looking floor plan. I also wanted to make sure the plans actually made sense.
That's where Kane CLI came in.
What is Furnish?
Furnish is an AI-powered home design studio.
You describe your plot, the number of floors, and the rooms you need. It generates an editable 2D floor plan with rooms, walls, doors, openings, and furniture.
From there, you can:
- Edit rooms and resize them directly on the canvas.
- Add rooms and furniture.
- Ask the AI assistant to make changes to your design.
- Switch between 2D and 3D views.
- Walk inside the building and explore it.
- Check room accessibility, door placement, furniture collisions, and other geometric constraints.
- Export your design as JSON, SVG, or PNG.
The important part is that this isn't just a 3D viewer.
The 2D plan and 3D building come from the same underlying project model. When you resize a room in 2D, the 3D version updates too.
Making the AI actually edit the design
One thing I wanted to avoid was an assistant that simply responds with text saying it has made changes without actually changing anything.
In Furnish, the assistant works through a registry of 28 typed tools.
It reads the existing project, plans the requested changes, checks whether those changes are valid, and applies them through the same operations used by the normal editor.
For example, if you ask it to add a study next to the largest room, it needs to work with the actual room geometry.
If you ask it to place a sofa where there isn't enough space, it should tell you why it cannot do that and suggest something that fits.
The assistant doesn't get to invent room IDs, bypass validation, or directly modify the project data.
The changes are applied step by step, and you can see them appearing on the canvas.
The interesting part: letting Kane CLI test it
An application checking its own output isn't enough.
For this hackathon, I wanted to use Kane CLI as an independent browser agent rather than just run a few predefined tests and show a green tick.
I wrote the project requirements in a PRD and handed them to Kane CLI.
Instead of giving it a fixed list of assertions, I gave it the requirements and asked it to verify the application through a real browser.
And it found problems.
The first run failed
Kane CLI identified nine errors:
- Two rooms had no way out.
- Three rooms couldn't be reached from the front door.
- The staircase had no door.
- Three pieces of furniture were blocking doorways.
These weren't just cosmetic issues. They were problems with the actual generated floor plan.
This was probably my favourite part of the entire process. The application looked fine at first glance, but an independent agent found things I had missed.
Fixing what Kane found
I took those findings back into development and changed how the generator works.
A few examples:
- Doors are now generated as a connected tree from the corridor, so rooms don't become passageways to other rooms.
- The staircase is accounted for before the rooms are partitioned.
- Furniture is placed after the room layout, keeping doorways clear.
Then I ran the same Kane CLI test again.
This time, it passed.
The important thing was keeping the same test definition rather than changing the test just to get a passing result.
There were more verification loops after that, covering things like the front door, staircase visibility, upstairs stair geometry, and the completeness of the verification history.
The Ledger: keeping failures too
I also added something called the Ledger inside Furnish.
It stores the Kane CLI verification history, including both passing and failing runs.
The recorded history contains 20 runs: 10 passed and 10 failed.
Each entry includes its commit, execution cost, duration, findings, and sealed evidence.
Why keep the failures?
Because showing only successful runs doesn't tell the complete story.
I wanted someone exploring the project to see what went wrong, what was fixed, and what the verification process actually reported.
The Ledger makes that history part of the application itself rather than something buried in terminal logs.
How I built it
I used an AI coding agent with GMI Cloud as part of the development workflow.
The project includes:
- React and TypeScript for the application.
- Vite for the frontend build.
- Three.js and React Three Fiber for the 3D environment.
- Express for the server-side API.
- MiniMax M3 for the AI assistant.
- IndexedDB for local project persistence.
- Kane CLI for independent browser verification.
The project also has its own deterministic geometry checker with 23 issue codes.
The AI can suggest changes, but the application calculates measurements and validates geometry itself.
For testing, I also built an end-to-end suite that runs against a real Chromium browser.
I also used Kane CLI to create the demo video
Something I wanted to try differently was the demo itself.
Rather than making a separate presentation explaining what happened, I used Kane CLI's actual terminal recordings, the failed audit, the successful re-run, and the Ledger inside the demo video.
The voiceover was generated using Inworld AI.
The idea was to let Kane CLI show its own verification process while the video demonstrates the application.
A few things worth mentioning
Furnish is an early-design tool, not professional architectural software.
The generated floor plans are not construction-ready or professionally certified. The geometric checks are configurable sanity checks, not building-code compliance checks for a particular location.
There is still plenty of room to improve the project.
But I'm happy with how the application turned out and, more importantly, with what the verification process helped uncover.
Try it out
GitHub: https://github.com/Joystonm/furnish
Demo video: https://www.youtube.com/watch?v=3oPcRKvGyFY
You can clone the repository and run it locally. It requires Node.js 22.16 or newer.
npm install cp .env.example .env npm run dev The studio supports manual editing without an API key. The AI assistant requires a MiniMax API key.
This was built for the Kane CLI Hackathon, and it was a fun experience experimenting with AI-assisted development and independent verification.
Thanks to the Kane CLI and TestMu AI teams for organizing it!
If you try Furnish, I'd love to hear what you think.
