AI FOR ARCHITECTS

Meet Conor and your cohort, get familiar with the course structure and set clear expectations for the weeks ahead, from weekly assignments to the final design proposal.

• Course structure and expectations
• Assignments and final project overview
• Instructor introduction

Discover how the course works, from the two-session week to the project brief, and take stock of where you and your cohort currently stand with AI in architecture.

• Course structure and marking
• The project brief
• Tool stack setup and licences
• Pre-course reading reflections
• Discussion: Where everyone actually stands with AI
• Demo: A selection of Conor's past work

Assignment #1: AI in Your Practice
Reflect on your current AI use, naming one tool you rely on, one you distrust, one task you'd delegate and one you wouldn't.

Learn how parametrics, optimisation, machine learning and generative models differ, and what each means for the reliability of the drawings you'll eventually sign off.

• Core AI technology categories
• Deterministic vs probabilistic output
• What each model type genuinely knows
• Common AI failure signatures
• Demo: Case studies of model types from practice
• Workshop: Classifying tools by technology type

Assignment #2: Tool Stack & Workflow Map
Table the course tools against each technology category and diagram where they could support your project's design process.

Understand how AI models are trained and trace how today's tools extend decades of computational innovation in architecture, from Sketchpad through to evolutionary solvers and learned surrogates.

• How models are trained
• Training data as an architectural problem
• From Sketchpad to evolutionary solvers
• Evolutionary architecture and form-finding
• Demo: Geometry, ML and AI applications from practice
• Workshop: Specifying training data for a lab-layout model

Assignment #3: Comparing Design Approaches
Compare how explicit rules, optimisation and machine learning would tackle one design task on your project, then choose the best fit.

Master the move from hand sketch to a set of diagrams that argue your design, using AI to speed up the drawing while you stay in charge of what it claims.

• The diagram as argument
• Sketch to vector to diagram
• Prompting for legibility
• Reading generated diagrams critically
• Demo: Processing a sketch through AI
• Workshop: Decoding and recreating an AI-generated diagram

Assignment #4: Sketch-to-Argument
Hand-sketch your intervention and produce five diagrams in one consistent language, logging every AI step, including the ones you rejected.

Explore how diffusion models work and learn to direct them so every image communicates the specific architectural intent, qualities and constraints of your proposal.

• How diffusion models work
• Prompt anatomy and negative prompts
• Visual quality vs geometric reliability
• Seeds and coherent image sets
• Demo: LLMs applied to an image of a 3D model
• Workshop: Reverse-engineering prompts from a real interior

Assignment #5: Images That Make a Claim
Generate six images from your project narrative, cut to three, and write one line on what each is actually proposing.

Discover how to hold geometry steady while exploring visual style, so your imagery stays an accurate, honest representation of the design you present to clients.

• Geometry conditioning techniques
• Consistency across material and light
• When to stop generating and start modelling
• Honest captions and provenance
• Demo: Exploring variations in visual style
• Workshop: Captioning three versions of one scheme for a client

Assignment #6: Six Images, One Geometry
Fix one model view, produce six studies varying only material and light, and submit the control image, settings and client caption.

Learn to frame architectural design problems as objectives, constraints and parameters so they can be explored, optimised and decided on computationally with confidence.

• Design space and Pareto fronts
• Where generative design earns its keep
• Grasshopper primer
• LLMs for editable parametric models
• Demo: Building a parametric model through LLMs alone
• Workshop: Sorting brief requirements into constraints and objectives

Assignment #7: Framing Your Design Problem
Express your coursework design problem as a clear set of objectives, constraints and parameters ready for computational exploration.

Run a real generative study on your own project, read the results with a critical eye and defend the option you would actually take forward.

• Sampling, solvers and convergence
• Reading a results grid
• Bringing options into Revit as native geometry
• Provenance and version control
• Demo: A simple parametric study and its outcomes
• Workshop: Choosing and justifying an option to a client

Assignment #8: Run a Study, Defend a Choice
Run a generative study on your project and present the results, defending your chosen option even if it isn't the top scorer.

Gain fast environmental feedback across your design options and learn exactly how far to trust it before committing to a full simulation.

• Environmental performance metrics
• Full simulation vs learned surrogates
• Ladybug and Honeybee primer
• Reading false-colour results
• The project's real performance drivers
• Demo: Daylighting study vs LLM prediction

Assignment #9: Your Key Performance Question
Identify your project's most important environmental question, the inputs it needs, and what you'd trust from rapid feedback versus full simulation.

Build a defensible context model from open and captured data, and state clearly what you know, what you have inferred and what you have invented.

• GIS and open data layers
• Computer vision on aerial and street imagery
• Scan-to-BIM and point cloud classification
• Post-occupancy data as design input
• Retrofit and existing-conditions data
• Discussion: Consent and benefit in post-occupancy data

Assignment #10: Context Model & Confidence Note
Produce your project's context model with a written note on what is surveyed, inferred and invented, and the consequences of each.

Discover what really eats delivery time, then get an LLM-written script running in Revit and understand it well enough to own every output it produces.

• pyRevit and Dynamo primer
• Owning LLM-written scripts
• Agentic tooling for Revit data
• Testing automations before go-live
• Demo: Creating a Revit script with an LLM
• Workshop: Decoding a pyRevit script line by line

Assignment #11: LLM Scripting Test
Have an LLM write a script for a real task in your model, run it, and record where it failed and what it assumed.

Master automated and AI-assisted checking of design information against project requirements, and find where machine validation ends and professional judgement begins.

• What to check in a design model
• Rule-based vs AI-assisted checking
• Limits of automation and professional sign-off
• Discussion: What a machine should never sign off
• Demo: Real-life QA case study from practice
• Workshop: Sorting requirements by machine vs human checking

Identify the problems worth automating and specify tools to solve them, with clear inputs, outputs and test cases that prove each one works.

• Choosing problems worth automating
• Tool shapes, from scripts to web apps
• Specifying before building
• What vibe-coding can and can't ship
• Demo: Real custom tools from practice
• Workshop: Scoring and ranking candidate tasks

Assignment #12: Draft a One-Page Spec
Define one tool on a single page: the problem, frequency, current time cost, inputs, outputs and three test cases.

Ship a working tool that runs on your own project data, taking it from spec to tested prototype and packaging it so colleagues can use it without you.

• From spec to working version
• Debugging with an AI assistant
• Testing against your three cases
• Packaging for colleagues
• Writing a limitations note
• Demo: Real custom tools from practice

Assignment #13: Prototype Tool
Build a working prototype tool with a limitations note that lets someone else use it independently.

Reflect on where AI added value to your project and where it fell short, then shape a personal position on its future in architecture alongside industry guests.

• How your project and methods evolved
• Lessons from successes and failures
• One brief, many valid methods
• What to adopt, pilot or approach with caution
• A personal position on AI in architecture
• Discussion: What you'll refuse to do with these tools