AI-NATIVE PRODUCT · PRODUCT DESIGN · CONCEPT
Architecture rarely begins with exact dimensions. It starts with a sketch, a reference, a constraint, or sometimes just an idea that is difficult to articulate.
I designed Arc around that transition: an AI-native design environment that lets architects begin loosely, then progressively introduce the precision needed to turn an idea into a viable building.
ROLE / CONTRIBUTION
Product concept · UX strategy · Interaction design · UI design · Product roadmap
THE PROBLEM
Architecture changes resolution as it develops.
Most tools don’t.
Early design is deliberately ambiguous. Architects sketch, collect references, test volumes and change direction quickly. Later, the same project becomes increasingly constrained by dimensions, programme, materials, performance, cost and regulation.
Digital tools tend to enter at one side of that process: either they support open ended exploration, or they demand structured information from the beginning.
I became interested in the space between them.
Could one environment become more precise as the design itself becomes more precise?
THE PRODUCT IDEA
One environment.
Two levels of precision.
Arc is built around two connected modes rather than two separate workflows.
Conceptual Mode keeps the interface intentionally light. An architect can begin with language, voice, a sketch or a reference and explore spatial possibilities without defining every parameter first.
Professional Mode progressively exposes the information needed to evaluate and develop the design — from site and programme to materials, performance and compliance.
The project stays the same. What changes is how much precision the designer asks from it.
DESIGNING THE INTERACTION
Start with intent, not configuration.
I borrowed one behaviour people already understand from conversational AI: describe what you want, then refine it.
Instead of opening with a dense architectural dashboard, Arc begins with a spatial workspace and a single prompt. Inputs such as sketches, references and site information can be introduced when they become useful rather than demanded upfront.
The interface grows with the conversation.
Familiar first
Start from an interaction people already know.
Progressive complexity
Reveal controls when the design needs them.
Spatial by default
Keep the emerging design at the centre of the interface.
CONCEPTUAL MODE
The first answer shouldn’t look finished.
In Conceptual Mode, AI acts less like a generator of final images and more like a design partner for testing possibilities.
A loose brief can become an initial massing proposal, which can then be challenged through further prompts: open the courtyard, increase daylight, respond to the site, preserve more outdoor space.
Each response becomes another design state rather than a final answer — keeping iteration visible instead of hiding it behind a single generated result.
AI should accelerate iteration, not prematurely resolve it.
PROFESSIONAL MODE
Precision enters when it becomes useful.
Switching to Professional Mode doesn’t restart the project. It changes the level at which the same design can be interrogated.
Structured inputs for site, programme, design intent and materials sit alongside live performance information, allowing the architect to move between shaping the building and understanding its consequences.
The ambition is not to automate architectural judgement, but to make more of the information behind that judgement available while decisions are still being made.
The tool becomes more technical without asking the designer to leave the design behind.
ITERATION AS A FEATURE
A design is a trail of decisions, not a single file.
Because exploration is iterative, Arc keeps previous directions accessible rather than treating every prompt as an overwrite. Designers can return to earlier versions, compare alternatives and continue from a branch that was previously abandoned.
PRODUCT EVOLUTION
Start with the design loop. Expand around it.
I wouldn’t try to build the entire vision at once. The useful first product is the smallest version that can prove the core behaviour: describe → generate → evaluate → refine.
From there, Arc could progressively absorb more of the intelligence surrounding architectural decisions without turning the first interaction into a cockpit.
WHAT I TOOK FROM IT
AI shouldn’t remove the messiness that makes design possible.
Designing Arc made me think less about AI as a feature and more about when intelligence should enter a creative process.
Architecture needs ambiguity at the beginning and precision later. Compressing that entire process into a single prompt might make generation faster, but it also removes many of the decisions that make designing valuable.
The more interesting opportunity is to build tools that understand when to suggest, when to calculate, and when to leave room for the designer to decide.
The goal isn’t to make architecture automatic. It’s to make moving from an idea to an informed decision less fragmented.