Inspiration
I'm an architect by training, and the most frustrating part of residential projects isn't "designing": it's the gap between what clients mean and what gets built.
In early-stage meetings, clients often describe a home in feelings and fragments: "bright but cozy", "open but private", "hotel-like", "minimal but warm". Architects translate that into plans through experience, but the exploration bandwidth is limited. We can’t realistically iterate dozens of layout hypotheses and validate every constraint (circulation, wet-core logic, daylight, privacy, adjacency) under real deadlines. The result is a familiar pattern: slow iteration, subjective drift, and expensive late-stage rework.
I studied generative design in a technical class, and I saw its promise, but also its ceiling. Traditional generative workflows often require the architect to be the final judge at every critical node. That's fine inside a professional team, but it breaks when the tool is used directly by clients: users may lack the professional vocabulary to specify requirements, and missing constraints can silently produce flawed designs.
This Hackathon felt like the right moment because Gemini 3 can do professional-grade reasoning over long context. The idea clicked: what if the model isn't just producing images, but acting like a design supervisor that can turn ambiguity into structure, keep decisions consistent across iterations, and explain why a plan changed?
That became ArchGener.
What it does
ArchGener is a client-facing pipeline where Gemini 3 becomes the "cognitive engine" for:
Analysis → Planning → Design Supervision → Visualization
Instead of asking users to “prompt an image,” ArchGener helps users arrive at a buildable idea through a traceable process:
It turns messy intent into a structured Design Contract (program + constraints + priorities), so the system knows what must be true and what can be negotiated.
It runs an iterative loop like a real design process: propose an approach, generate a layout candidate, polish locally, evaluate, then iterate.
It keeps the process auditable by maintaining a reasoning trail ("traceability") so decisions aren't a black box.
It converges to visuals that reflect the underlying plan: not just a pretty render disconnected from the layout logic.
At a high level, the engine treats planning like a constrained optimization problem with real-world trade-offs. Conceptually:
$$ minJ = w_v V + w_c C + w_a A + w_d D $$
Where 𝑉 penalizes hard violations (non-negotiables), while 𝐶, 𝐴, 𝐷 represent soft objectives like circulation efficiency, adjacency satisfaction, and daylight proxies.
How we built it
We embraced a "Vibe Coding" workflow to maximize speed and creativity, treating Gemini 3 as our lead engineer:
The Brain (Google AI Studio): We used AI Studio to rapid-prototype the complex orchestration flows. We designed the "Supervisor" system prompts here to test how Gemini handles multimodal inputs and strict JSON schema adherence.
The Engine (Node.js + Typescript): For the heavy lifting, we utilized Codex to write the backend logic. This includes the Constraint Solver and the Space Partitioning Algorithms (e.g., Squarified Treemaps) that convert the Agent's abstract instructions into Euclidean geometry.
The Face (React + Vercel): A responsive UI that visualizes the "thinking process" of the AI, deployed for real-time interaction.
We modularized the system into distinct agents:
Contract Builder: Ambiguity resolver.
Layout Supervisor: The strategic reasoner.
Geometry Engine: The deterministic builder.
Challenges we ran into
The Ambiguity-Determinism Gap: Users speak in feelings ("I want a cozy home"), but code needs math. Bridging this gap required extensive prompt engineering to teach Gemini how to translate "cozy" into specific spatial constraints (e.g., "smaller aspect ratios," "warm material palette").
Constraint Conflicts: Real architecture is a trade-off. Maximizing daylight often hurts thermal efficiency; privacy fights with open-plan desires. We had to teach the Supervisor Agent to prioritize and make trade-offs, rather than getting stuck in infinite loops.
Hallucination vs. Geometry: Early versions using pure LLM generation for coordinates resulted in "Escher-like" impossible rooms. We solved this by separating concerns: Gemini handles the Topological Logic (Graph), while deterministic algorithms handle the Geometric Execution (Canvas).
Accomplishments that we're proud of
End-to-End Pipeline: We successfully built a working prototype that goes from a fuzzy text prompt all the way to a rendered floor plan without human intervention in the middle.
Auditable AI: We achieved "Traceability." Users can click a room and see why it's there (e.g., "Placed East for morning light as requested in brief").
Architectural Logic: We proved that LLMs can do more than just write code or chat. They can understand spatial relationships and act as a domain-specific supervisor.
What we learned
LLMs as Orchestrators: The true power of Gemini 3 isn't just generating text, but structuring unstructured data to drive downstream deterministic tools.
Constraints are King: In generative design, the "secret sauce" isn't the generation algorithm, but the quality of the constraints. Gemini 3 excels at defining these constraints.
Vibe Coding Works: We built a complex full-stack application with a small team by leveraging AI to handle the boilerplate, allowing us to focus on the architectural logic.
What's next for ArchGener
Push single-house concept generation toward professional-grade output: More robust constraint libraries, better evaluation proxies, and higher reliability across diverse sites and lifestyles.
Complex Typologies: Expanding beyond single-family residential into high-constraint domains like Senior Living or Healthcare, where adjacency rules (e.g., nurse station visibility) are critical and binary.
Reduce industry gatekeeping through tooling: Long-term, I want ArchGener to lower the cost of "finding what you actually want". So clients can explore intelligently before committing to a specific firm’s style and limitations, and so smaller teams can compete on capability, not just headcount.
Built With
- aistudio
- express.js
- gemini3
- node.js
- react
- tailwind
- typescript
- vite
- zod
Log in or sign up for Devpost to join the conversation.