Studio Matrx Monthly · Volume 1 · Issue 3 · August 2026
Amogh N P
 In loving memory of Amogh N P — Architect · Designer · Visionary 
AI Floor-Plan Generators & LimitsLesson 8.2

Lesson 8.2 · Beyond Images

AI Floor-Plan Generators & Limits

What Maket, Finch and their kin genuinely do - and the hard line before a buildable plan

14 min Interactive lessonFree · open lessonByAmogh N P· Architect & interior designer
The hook

A layout in seconds is not a building in seconds.

Type your room list, draw your plot, set the setbacks, and a tool like Maket or Finch returns a dozen floor plans before your tea cools. It feels like magic, and for the right job it genuinely helps. But a plan is the easiest 10 percent of a building to draw and the hardest 90 percent to make real - and the generator only does the easy part. This lesson maps exactly what these tools do, and the hard line they cannot cross.

The plan is the easy 10 percent. The tool only does the easy part.

What the tool is really doing

An AI floor-plan generator is best understood as a constraint-solver with a learned sense of layout. You give it inputs - a site boundary, a schedule of rooms with target areas, adjacency preferences ('kitchen near dining', 'bedrooms away from the street'), setback and coverage rules, sometimes a style preset. The tool then searches an enormous space of possible arrangements and returns the ones that best satisfy your constraints, packing rooms into the footprint like a very fast, tireless puzzle-solver.

Under the hood, current tools blend two lineages. One is classical optimisation and procedural rules - decades-old space-planning algorithms that treat the plan as a packing-and-adjacency problem to be solved mathematically. The other is learned generative models - the same family of ideas you have met all course, here trained on large datasets of real plans so the output inherits patterns that 'look like' how buildings are actually laid out. Some tools also bolt an LLM (Module 8.1) onto the front so you can describe what you want in plain language. The exact recipe varies by product and it keeps changing; what matters is the shape of the thing: constraints in, many candidate arrangements out.

The honest mental model is a bubble diagram that draws itself. Every architect starts a project by sketching rooms as blobs and testing how they connect; the generator automates that first, divergent, throw-lots-at-the-wall stage and does it faster and more exhaustively than a human can. That is a real and useful thing. It is also, crucially, only that thing - and the rest of this lesson is about the gap between a good bubble diagram and a building.

PLAN-GENERATOR PIPELINE INPUTS site outline room list + areas adjacencies setbacks / rules style presets GENERATOR optimise + learned layout patterns -> many candidates CANDIDATES YOU pick, edit, detail, resolve THE GENERATOR DOES NOT DO: structure + spans - services routing - real code compliance - context + climate logic buildable detail - cost reality. It hands you a diagram to argue with, not a drawing to build.
Zoom
The plan-generator pipeline. Constraints go in, the engine returns many candidate arrangements, and you pick and resolve. The dashed line marks everything the generator does not do - structure, services, real code, context and cost.

Constraints in, many arrangements out. A bubble diagram that draws itself.

The jobs it genuinely does well

Used for what it is, a plan generator earns its place in a practice - especially at the front of a project, where speed and breadth matter more than resolution.

Rapid option generation. The single best use. Where you might sketch three layouts by hand, the tool floats thirty, some of which try adjacencies you would not have. Even the bad ones are useful - they map the edges of the solution space and sharpen your sense of what the good move is.

Feasibility and yield studies. Given a plot and a set of rules, how many units fit? Does the program even close on this footprint? The generator answers 'roughly, does this work at all?' in minutes, which is exactly the question a client asks before committing to a site - and exactly the stage where a rough answer is enough.

Packing and adjacency testing. For tightly-constrained problems - a compact urban plot, a repetitive apartment floor - the tool is genuinely good at cramming a room schedule into a footprint and honouring adjacency wishes, the fiddly geometric bookkeeping that eats hours by hand.

A starting point to edit. Perhaps its truest role: not a final plan but a first draft to react against. Designers often work faster fixing a plausible generated layout than staring at a blank page, because a concrete proposal is easier to critique than a void.

The pattern mirrors Module 8.1 exactly: the tool is strong at diverging fast and cheap and weak at resolving to something real. Use it where breadth and speed are the point, and hand off to your own judgement the moment resolution becomes the point.

There is a subtler benefit worth naming, too. Because the generator is tireless and unattached, it proposes arrangements a human quietly rules out from habit - the stair on the wrong side, the service core in an unexpected place, two programs swapped. Most are wrong, but occasionally one of those unfamiliar moves is the seed of a genuinely better plan you would never have sketched, precisely because you carry a lifetime of sensible defaults the machine does not. Treated as a provocateur rather than an authority, the tool can widen your thinking as much as it speeds it - which is a real, if quieter, kind of value.

DOES / DOES NOT GENUINELY USEFUL FOR DO NOT TRUST IT FOR - fast bubble / block options - packing rooms into a footprint - testing many adjacency ideas - early feasibility on a site - yield studies on a plot - a starting point to edit - structural grid + spans - actual bye-law compliance - services, ducts, shafts - fire egress + travel distance - buildable dimensions - a plan you submit as-is A generated plan is a hypothesis about arrangement. The architect still supplies the structure, the code, the services and the judgement that make it a building. Treat the output as sketch input to your process, never as the deliverable.
Zoom
Does versus does not. On the left, the early, divergent jobs where a plan generator genuinely helps; on the right, the resolution work - structure, code, services, buildability - that keeps it a sketch tool, not your drawing.

The hard limits - where the plan stops being real

Now the part the marketing skips. A generated plan is a diagram of arrangement, and a building is enormously more than arrangement. Several hard limits separate the two, and none is a temporary gap the next version quietly closes.

Structure. The generator packs rooms; it does not resolve a structural grid, column positions, beam spans, or how loads travel to the ground. A plan that looks fine can be quietly unbuildable because a 9-metre clear span sits where no economical beam wants to be. Services. Plumbing stacks, electrical routing, HVAC ducts, shafts and risers - the systems that make a building habitable - are largely invisible to these tools, yet they dictate where wet areas can stack and where a false ceiling must drop. Code and bye-laws. A tool can honour the setbacks and coverage you typed in, but real compliance - fire egress and travel distances, ventilation minimums, staircase geometry, the specific development-control rules of this municipality - is deep, local, and mostly beyond what the generator checks. It obeys the rules you fed it, not the rules that actually govern the site.

Buildability and dimension. Generated dimensions are often approximate - walls without real thickness, rooms that don't quite coordinate with a block or brick module, junctions no one detailed. Context and climate. The tool doesn't know this plot slopes, that the good view is north-west, that monsoon orientation matters here, or that the neighbour's wall casts the courtyard into shade. Cost. A layout says nothing about whether it can be built for the budget. Every one of these is a domain where an architect's judgement is not decoration but the actual value - and the honest way to read a generated plan is as a hypothesis about arrangement that you must then make into a building. (For Indian projects the code-and-climate gap is especially wide; a Studio Matrx guide with a verified date is a better authority on a bye-law than any generator's confident-looking output.)

DOES / DOES NOT GENUINELY USEFUL FOR DO NOT TRUST IT FOR - fast bubble / block options - packing rooms into a footprint - testing many adjacency ideas - early feasibility on a site - yield studies on a plot - a starting point to edit - structural grid + spans - actual bye-law compliance - services, ducts, shafts - fire egress + travel distance - buildable dimensions - a plan you submit as-is A generated plan is a hypothesis about arrangement. The architect still supplies the structure, the code, the services and the judgement that make it a building. Treat the output as sketch input to your process, never as the deliverable.
Zoom
Does versus does not. On the left, the early, divergent jobs where a plan generator genuinely helps; on the right, the resolution work - structure, code, services, buildability - that keeps it a sketch tool, not your drawing.

It packs rooms. It does not resolve structure, services, code or cost.

Using them without being used by them

None of this is a reason to avoid the tools - it is a reason to place them correctly in the workflow. The failure mode is not using a plan generator; it is believing its output, handing a generated plan to a client as resolved, or worse, toward a submission, when it is a sketch wearing the costume of a drawing.

The disciplined workflow puts the generator where it belongs - early, and upstream of judgement. Generate widely to explore; harvest the two or three arrangements that spark something; then leave the tool and bring the winner into your real process, where you resolve structure with an engineer, coordinate services, check it clause by clause against the actual bye-laws, detail the junctions, and test it against the site and climate. The generator compressed the divergent front end; the convergent, resolving, professional work is still entirely yours - and it is where your value lives.

There is a quieter reason to keep the tool on a short leash: its convenience is persuasive. A clean, rendered, instantly-produced plan looks finished, and that polish can seduce you (and your client) into skipping the hard resolution the plan hasn't had. Guard against it deliberately. Say out loud, to yourself and the client, that this is an option-study, not a design - the same honesty Module 8.1 demanded of an LLM's confident prose and Module 0 demanded of a seductive render. The through-line of this entire module is one discipline in three costumes: the AI produces a fluent surface; you supply the substance and you own the result.

PLAN-GENERATOR PIPELINE INPUTS site outline room list + areas adjacencies setbacks / rules style presets GENERATOR optimise + learned layout patterns -> many candidates CANDIDATES YOU pick, edit, detail, resolve THE GENERATOR DOES NOT DO: structure + spans - services routing - real code compliance - context + climate logic buildable detail - cost reality. It hands you a diagram to argue with, not a drawing to build.
Zoom
The plan-generator pipeline. Constraints go in, the engine returns many candidate arrangements, and you pick and resolve. The dashed line marks everything the generator does not do - structure, services, real code, context and cost.

Generate widely, then leave the tool. The resolving work is yours.

Tools & techniques you'll meet in this lesson

Maket (text/constraint-driven plan generator)

Generates residential floor-plan options from a room list, constraints and plain-language prompts

Fast, broad early-stage option generation; output is a diagram to edit, not a coordinated or code-checked drawing.

Finch (parametric / generative layout tool)

Real-time generative layouts and feedback on space use and yield

Strong for feasibility and packing studies; still does not resolve structure, services or local bye-laws.

Constraint solving + learned layout priors

The engine: optimisation and rules blended with models trained on real plans

Explains what it is good at (satisfying stated constraints) and blind to (everything you did not, or could not, state).

Feasibility / yield study

The genuine professional use case - 'does the program close on this site, roughly?'

A minutes-not-days answer at the stage where a rough answer is exactly enough.

Hands-on workshop

Workshop - generate ten plans, then audit them like an architect

You'll use a plan generator for the job it is good at, then apply the professional judgement it can't - proving to yourself exactly where the line sits. Use Maket, Finch, or any AI plan tool you can access.

Any AI floor-plan generator (Maket, Finch, or a comparable tool; free trials suffice) and pen and paper or any sketch app for the correction.

Given & goal
Goal: separate what the tool resolves from what it leaves for you
Inputs: an AI plan generator + a simple brief (a small house or a shop floor)
Time: ~45 minutes
  1. 1Set up a real brief: draw a plot, list rooms with target areas, state two adjacency rules and the setbacks. Generate at least ten layout options.
  2. 2Curate like a designer: pick the two most promising and write one line on why each caught your eye (a clever adjacency, an efficient core).
  3. 3Now audit the hard limits on your favourite. For each of structure, services, code/egress, buildable dimensions, and site/climate, note one concrete thing the plan has NOT resolved.
  4. 4Redraw one fix by hand: take a single unresolved issue (say a wall that doesn't align to a structural grid, or a wet area that can't stack) and sketch the correction over the generated plan.
  5. 5Write the placement rule: in one paragraph, state exactly where in a real project you would use this tool and where you would stop trusting it.

You’ll walk away with
A short study containing your ten generated options, your two curated favourites with rationale, a five-point 'not resolved' audit of one plan, and your hand-drawn correction plus a written placement rule for the tool.

The worked example

Three altitudes on the same idea

Read the band that fits you — or all three.

For the architectConcept, form & communication

Place plan generators at the front of the project, not the end. They are genuinely strong for rapid option-generation, feasibility and yield studies, and packing tightly-constrained footprints - the divergent early work where breadth beats resolution. Then leave the tool: structure, services, real bye-law compliance, buildable dimensions, context and cost are yours and your consultants', and none of them is a gap the next version closes. Read every output as a hypothesis about arrangement, and never let a rendered-looking plan skip the resolution it has not had.

For the interior designerStyle, materials & mood

For interiors the useful zone is furniture layout, circulation and space-planning options within a shell that already exists. A generator can throw a dozen arrangements of a living-dining-kitchen or a retail floor faster than you can sketch them, which is a great way to test adjacencies and flow with a client. But it doesn't know your real service points, the immovable column, the door you can't move, or the exact clearances a wheelchair or a dining chair needs. Use it to diverge, then resolve the plan by hand against the true constraints of the actual room.

For the studentSkills, portfolio & jobs

These tools are a superb studio-learning aid precisely because they externalise the bubble-diagram stage you are trying to master. Generate ten layouts for a brief, then critique them: which adjacencies work, which spans are unbuildable, where code would object, what the tool missed about site and climate. That critique - not the generation - is the skill being examined, and being able to say exactly why a slick generated plan is not yet a building is what marks you out as a designer rather than an operator of software.

Misconception check

AI floor-plan generators are close to producing buildable, code-compliant plans you can submit - the technology is nearly there and the next version will close the gap.

The gap is not a maturity problem the next release quietly fixes; it is structural. These tools solve arrangement - packing rooms and honouring the adjacencies and setbacks you type in. A building additionally requires resolved structure, coordinated services, real and local code compliance, buildable dimensions, and response to site, climate and cost - domains largely outside what the generator models at all. A generated plan is a fast, useful hypothesis about layout. Turning it into a building is the architect's work, and it always will be.
Try it

Do it yourself

No tool needed - reason it through.

  1. 1In one sentence, what class of problem does a plan generator actually solve?
  2. 2Name three of the hard limits that separate a generated plan from a buildable one.
  3. 3Why is 'feasibility / yield study' a genuinely good use but 'a plan to submit to the authority' a bad one?
  4. 4A tool honoured your setbacks and coverage. Why is that NOT the same as code compliance?
  5. 5Where in a project timeline should a plan generator sit, and where should you set it down?
Take this with you

The one line to carry out

An AI floor-plan generator is a bubble diagram that draws itself - superb for fast, broad, early option-and-feasibility work, and blind to structure, services, real code, buildability, context and cost - so use it to diverge, then leave it and do the resolving work that turns an arrangement into a building yourself.
Take it further
References & further reading

Peer-reviewed journals & authoritative standards

  1. 01OpenAI - GPT-4 Technical ReportarXiv preprint, 2023.
  2. 02Goodfellow, I., Pouget-Abadie, J., Mirza, M., et al. - Generative Adversarial NetworksAdvances in Neural Information Processing Systems (NeurIPS), 2014.
  3. 03Vaswani, A., Shazeer, N., Parmar, N., et al. - Attention Is All You Need (the Transformer)Advances in Neural Information Processing Systems (NeurIPS), 2017.
Related lessons
Recap
Plan generators like Maket and Finch solve arrangement: constraints in, many candidate layouts out, via optimisation blended with learned layout priors. They are genuinely useful for rapid options, feasibility and yield studies, packing, and a first draft to edit. They do not resolve structure, services, real and local bye-laws, buildable dimensions, site, climate or cost. Generate widely early, then hand off to your own judgement.
Carry forward →

Plans are 2D. Next the AI reaches into three dimensions - text-to-3D that invents objects from a prompt, and NeRF and Gaussian splatting that capture real space into a navigable scene. Thrilling, early, and with their own honest ceiling.

A

The author

Amogh N P

Architect, interior designer, and creative polymath. Studio Matrx began in his notebooks — his vision of design made honest, useful, and open to everyone. Its Academy is written and taught in his memory, and free, forever.

More about Amogh →