Architects and AI Guide Get the 139-page guide — $20

You don't need another AI tool. You need to know which ones to ignore.

The Ultimate Guide for Architects Using AI is 139 pages of that judgement — which tools earn a place in a real workflow, what adopting one actually costs, and the point where it stops being worth the trouble.

From the creator of Architects and AI, a channel that runs these tools against the work architecture teams do and publishes what happens.

Get the 139-page guide — $20

PDF, instant download. Checkout runs on Payhip.

Free: the 3 saved prompts from the video
Cover of The Ultimate Guide for Architects Using AI: an isometric drawing of a three-storey building, one half a solid model and the other a cyan wireframe threaded with data nodes.
Format
PDF
Pages
139
Parts
10
Chapters
62
Price
$20 USD
From
Architects and AI

01

Nobody is paying you to evaluate AI software.

Something launches every week promising to redraw your plans, write your reports, or pull a scheme out of a sketch. A few are genuinely useful. Sorting those from the rest is unbilled research, and it lands on whoever was curious enough to try.

  1. i

    The demos aren't project work.

    Launch videos run on clean, invented briefs. Your model carries four consultants' revisions and a client who rewrote the brief in month seven. Tools behave differently there, and the difference is the whole story.

  2. ii

    Nobody publishes the failures.

    Vendors show you the output that worked. What matters is the third attempt, and whether correcting it took longer than doing the job by hand.

  3. iii

    The cost of finding out lands on you.

    A trial account, an afternoon of setup, a week of fighting the output, then the quiet decision to go back to the old way. That is the real price of evaluating a tool — and you pay it per tool.

This book is that work already done: what held up, what didn't, and which failures to expect before they cost you an afternoon.

02

What's inside

Ten parts, 62 chapters. It opens with what these models are actually doing when they answer you, works out through the tools and the project stages where they earn their place, and closes on verification, professional risk, and folding the whole thing into a working week.

  1. Part I Getting Oriented 6 chapters
    1. 01What a language model is doing when it answers you
    2. 02Why it sounds confident when it's wrong
    3. 03The three things AI is genuinely good at in architecture
    4. 04The four things it cannot do, and won't soon
    5. 05Why “it saved me a week” and “it wasted my afternoon” are both true
    6. 06Setting a realistic expectation before you spend money
  2. Part II The Tool Landscape 8 chapters
    1. 07Text models: the general assistants
    2. 08Image generators: concept and visualization
    3. 09Plan generators: what they actually produce
    4. 10Rendering and post-processing tools
    5. 11Plugins inside your existing software
    6. 12Document and code-search tools
    7. 13How to evaluate a new tool in twenty minutes
    8. 14The subscription trap: what's worth paying for
  3. Part III Speaking to the Machine 7 chapters
    1. 15Why architectural vocabulary produces better output
    2. 16Program, brief, and constraint
    3. 17Organisation types as prompt terms
    4. 18Describing spatial quality without adjective soup
    5. 19Reference images and what they actually control
    6. 20Iteration: the second prompt matters more than the first
    7. 21Building a reusable prompt library
  4. Part IV Concept and Early Design 6 chapters
    1. 22Generating options faster than you can sketch them
    2. 23Massing studies and site response
    3. 24Precedent research without the rabbit hole
    4. 25Testing a brief against itself
    5. 26Where AI concepts fall apart under program pressure
    6. 27Presenting AI-assisted concepts to a client, honestly
  5. Part V Drawings and Documentation 6 chapters
    1. 28What plan generators actually produce, tested
    2. 29Why AI can't hold dimensional consistency
    3. 30Detail libraries and annotation assistance
    4. 31Drawing review: using AI to catch your own errors
    5. 32Sheet setup, titleblocks, and the boring wins
    6. 33The honest state of AI-to-BIM
  6. Part VI Words 7 chapters
    1. 34Specifications: drafting, comparing, checking
    2. 35Design narratives and competition text
    3. 36Fee proposals and scope descriptions
    4. 37Client emails that took an hour, in five minutes
    5. 38Meeting notes to action items
    6. 39Planning statements and submission documents
    7. 40Keeping your voice, not the machine's
  7. Part VII Analysis 5 chapters
    1. 41Code research: how far to trust it
    2. 42Zoning and site constraint checks
    3. 43Energy and daylight: what AI can and can't model
    4. 44Cost estimation and why it's dangerous here
    5. 45Reading long technical documents fast
  8. Part VIII Verification 5 chapters
    1. 46The verification habit
    2. 47How to spot a fabricated citation
    3. 48How to spot a plausible wrong number
    4. 49The categories of error, and which are dangerous
    5. 50Building a check step into every workflow
  9. Part IX Practice and Professional Questions 7 chapters
    1. 51The questions to ask before AI touches client work
    2. 52Standard of care: an open question worth watching
    3. 53What never goes into a chat box
    4. 54Client data and third-party tools
    5. 55Copyright and AI-generated images
    6. 56What to raise with your insurer and your contracts
    7. 57What to tell a client, and when
  10. Part X Building the Workflow 5 chapters
    1. 58Auditing where your hours actually go
    2. 59Choosing the three tasks to automate first
    3. 60The weekly review that keeps the system honest
    4. 61Introducing this to a team that doesn't want it
    5. 62Staying current without chasing every release

03

Who this is written for — and who should skip it

Written for

Practice owners and directors
You decide what the practice adopts, what it pays for, and what it tells clients about how the work gets made.
Project architects and job runners
You need tools that hold up on a live job with a real programme, not on a demo file.
Part 2s and recent graduates
You'll be the person asked to "look into AI". This gives you something defensible to come back with.
BIM coordinators and technologists
The modelling, data and file-hygiene chapters are written for your side of the job.
Students heading into practice
Learn where these tools sit in a real workflow before someone hands you one and expects an answer.

Not written for

You want a pack of prompts to paste in
Prompts go stale in weeks. Part III teaches you to write your own instead, which doesn't.
You want software that designs the building
It doesn't exist. Chapter 4 is called “The four things it cannot do, and won't soon”, and the book means it.
You're building AI products for the industry
This is for people choosing tools, not people making them. You'd be reading it sideways.
You already run structured tool evaluations
If you keep your own notes on everything you've tested, you're ahead of this book.
You need legal or contractual advice
Part IX covers client data, copyright and what to raise with your insurer, in practical terms. It isn't professional advice and doesn't pretend to be.

04

Look inside

The contents above name every chapter. These pages show how they read.

Placeholder

assets/sample-1.jpg

Sample spread

Placeholder

assets/sample-2.jpg

Sample spread

Or read the full contents above — all ten parts, all 62 chapters, listed.

Get the 139-page guide — $20

05

Who wrote this

I run Architects and AI, a YouTube channel about using AI tools in architectural work. I run software against the kinds of tasks architecture teams do and publish what happens, including the runs where the tool loses.

My side of this is the testing. I put each tool through the same work repeatedly, record where it holds and where it gives way, and write it up in terms the people who do run projects can act on. Practice is their expertise. How the software actually behaves is what I can tell you about.

That's why the book is organised around workflows and evidence rather than opinions about design — and why a whole part of it is verification: catching the confident, plausible, wrong answer before it reaches a drawing.

06

Watch the testing

Every long-form video from the channel. Each one takes a tool or workflow, runs it on architecture work, and says where it holds up.

  • I Let Claude Run My Architecture Project Alone: Here’s What Happened

    7:20

  • The Top 10 AI Trends in Architecture You Can't Afford to Miss

    10:35

  • ChatGPT vs Claude: Which AI Is Actually Better for Architects?

    8:14

  • Midjourney vs Vizcom vs NanoBanana: A Brutally Honest Comparison

    11:06

  • I Used ChatGPT Astra to Design a Futuristic House. The Result was Insane!

    8:42

  • Don't Just Prompt ChatGPT — Build a Reusable Architectural System

    11:05

  • Claude vs ChatGPT: Who Wins the Floor Plan Challenge?

    8:51

  • I Tested ChatGPT for Architecture Work. Here Are the Only 7 Prompts You Need

    9:00

  • I Let AI Design a House With Zero Help. It Almost Worked.

    10:16

  • I Tested 5 'Free' AI Tools for Architects—Here’s What Happened

    11:43

  • I tried 5 AI renderers so you don't have to

    14:14

  • How to Get More Out of AI Rendering Tools on an Architecture Project

    11:36

  • I Tested ChatGPT on a Real Architecture Project—The Results Surprised Me!

    6:44

  • I Tested Every AI Floor Plan Generator. Most Are Toys

    14:04

  • This AI Workflow Does a Week of Architecture Work in Hours

    9:45

New videos go up on youtube.com/@ArchitectsAndAI.

07

Questions

  • What exactly do I get?

    One PDF: 139 pages, 10 parts, 62 chapters. It reads on a laptop, tablet or phone, though the diagrams are easier on a larger screen.

  • How is it delivered?

    Payhip handles checkout and sends a download link by email as soon as the payment goes through. No account to create, no subscription.

  • Won't this be out of date in six months?

    Parts of it will. Interfaces and pricing change constantly, so the book is built around what each class of tool is good and bad at, which moves far more slowly. Where something is likely to date fast, the text says so.

  • Do I get future updates?

    Yes. Revised editions are free to anyone who has already bought it — you don't pay again for the next version.

  • Do I need experience with AI tools?

    No. Part I starts at what a language model is actually doing when it answers you. If you already use these tools daily, start at Part II — the tool landscape, and how to judge a new one in twenty minutes.

  • Can I share it across my practice?

    It's a single-reader licence. The copy is for you rather than for the practice, so colleagues who want one would need their own.

  • What's the refund policy?

    There isn't one. It's a digital file that downloads the moment you pay, so sales are final. That's why the contents above list all 62 chapters — read them, and buy only if the book covers what you need.

  • Are you an architect?

    No. I test AI tools and report what holds up for architecture teams; I have no architectural training and don't work at a practice. The book is written from that position — it tells you how the software behaves, not how to design.

08

Get the guide

$20 USD

139 pages · 10 parts · 62 chapters · PDF

Get the 139-page guide — $20

Payhip takes the payment and emails the download link. The file is yours to keep.

Free · From the video

The 3 saved prompts

The full pipeline from the video. Build the setup once — Custom Instructions, one Project per job, these three prompts — and stop re-typing your instructions on every project. Each one assumes you're working inside a ChatGPT Project with your own files uploaded: the brief, your code and zoning documents, your drawings. That's what turns the model from something that remembers into something that reads.

Prompt 01

The Brief

Turns raw call notes into a structured brief you can design against — with every line marked stated, implied or missing, so you can hand it straight back to the client for confirmation.

SOURCE
Use only my raw notes and the files in this Project. Do not add
requirements, preferences, standards or budget figures that
aren't in them. Do not fill gaps with what's typical for this
project type.

TASK
Turn my raw notes into a structured architectural brief I can
design against and send back to the client for confirmation.

STRUCTURE
- Project summary, three sentences
- Client goals: what they want, and where stated, why
- The people: who lives or works here, how many, how they use
  the space
- Site: address, orientation, access, slope, existing structures,
  neighbours, anything they mentioned about the setting
- Program: every space named, with any size, quality or
  adjacency note attached to it
- Constraints: planning, zoning, heritage, access, services,
  timeline
- Budget signals: figures given, and any indirect signal
  (finishes named, comparisons made, phrases like "nothing fancy")
- Priorities: what they'd protect if the budget tightened, and
  what they'd drop
- Timeline and any fixed dates

TRACEABILITY
Against every line, mark one of:
STATED - quote the words from my notes
IMPLIED - my notes point to it, say which line and how
MISSING - not in the notes at all
Never write a line without one of these marks. If a section is
entirely MISSING, say so rather than producing a plausible one.

QUESTIONS
Then a numbered list of every question I still need answered,
ordered by what blocks design work soonest. For each, say in one
line what it changes if the answer goes either way.

CONTRADICTIONS
List anywhere my notes conflict with each other, or where a
stated goal doesn't fit a stated constraint or budget signal.
Quote both sides. Don't resolve it.

OUTPUT
The brief, then the questions, then the contradictions. No
preamble, no summary of what you did.

Prompt 02

The Code & Zoning Checklist

Only works once your jurisdiction’s documents are uploaded to the Project. Every line comes back with a section number and a word-for-word quote, or it comes back marked “not in sources.”

JURISDICTION
City / county: [    ]        State: [    ]
Building code adopted: [    ] edition, with [state] amendments,
effective [date]
Residential code, if separate: [    ]
Fire code: [    ]   Energy code: [    ]   Accessibility: [    ]
Zoning ordinance: [    ], last amended [date]
Zoning district: [    ]   Overlays: [    ]
Use group / occupancy: [    ]   Construction type: [    ]
Storeys: [    ]   Sprinklered: [yes / no]
Anything blank above: don't assume it and don't use a national
default. Add it to the missing documents list and stop.

SOURCES
Use only the documents uploaded to this Project. Do not use
general knowledge of building codes, and do not rely on anything
you remember about this jurisdiction.
Before the checklist, list every document you'd need but don't
have, and name it specifically enough that I can go find it.

PRECEDENCE
Where documents overlap, the more local one governs: local
amendment over state amendment, state amendment over model code.
Where a local amendment changes a model code figure, show both,
say which governs, and cite both sections.
Where the zoning ordinance and the building code both touch an
item, such as height, treat them as separate requirements and
list both.

SCOPE
Egress and travel distance, stair and guard geometry, corridor
and door widths, room sizes, ceiling heights, light and
ventilation, fire separation and ratings, structural and energy
where the documents cover it, setbacks, height, lot coverage and
FAR, parking and loading, and accessibility.

FOR EACH ITEM
- The requirement, in plain language
- The governing number or threshold
- Document name, section number, and page
- A word for word quote of the sentence that number comes from
- Status: VERIFIED, quoted from an uploaded document
           NOT IN SOURCES, needs verification
           CONFLICT, two documents disagree, show both and cite both
- Whether it's a hard limit or subject to a listed exception, and
  quote the exception
- How this project stands against it, if the brief or drawings in
  this Project give me the figure. Otherwise mark it as unchecked.

RULES
Never cite a section you can't quote. If the section number and
the quote don't match, output NOT IN SOURCES instead.
Never paraphrase a number into the quote field.
Don't mark anything verified on the strength of a table alone
without naming the table and its conditions.

OUTPUT
Missing documents first. Then the checklist, grouped by building
code and zoning. Then a short list of every item where a local
amendment changed the model code figure, because those are the
ones I'm most likely to get wrong from memory.

Prompt 03

The 2D to 3D Model Handoff

Fill the geometry block once per project. Anything left blank gets added to the missing list instead of being guessed — and the dimension report tells you exactly which numbers to check.

SOURCE
Use only the floor plan, elevations and program in this Project.
Do not invent dimensions, rooms, levels or openings that aren't
on the drawings.

BEFORE YOU MODEL
List everything missing that would change the geometry: floor to
floor height, wall and partition thicknesses, slab thickness,
door and window head and sill heights, roof form and pitch, level
changes, north orientation, and drawing scale. Ask for those. Do
not pick values to fill the gaps.

GEOMETRY
Units: [mm / m / ft-in]. Work in this unit throughout.
Floor to ceiling height: [    ]
Floor to floor height: [    ]
Exterior wall thickness: [    ]
Interior partition thickness: [    ]
Slab / floor thickness: [    ]
Door head height: [    ]
Window head height: [    ]   Window sill height: [    ]
Roof: [flat / pitched at    / not modelled]
Number of levels: [    ]
Anything left blank: do not assume a value and do not use a
regional default. Add it to the missing list and stop.
Take every other dimension from the drawings, not from typical
construction. Where a drawing gives a figured dimension, that
figure wins over anything scaled.

OUTPUT
An editable SketchUp model. Every element a named component or
group, tagged by material, organised so I can lock the shell
independently of the interior.
Named scenes for each elevation, plus plan and one isometric.

VERIFY
Return a dimension report with the overall footprint, each room's
clear dimensions and area, and every thickness used. Mark every
value you inferred rather than read off the drawing.
Where the plan and the elevations disagree, list the conflict.
Don't resolve it silently.

The rule that holds all three together. Every stage produces a draft, not a deliverable. Verify every code citation against the published document, overlay every model against your real site dimensions, and read every client-facing word before your name goes on it. The AI doesn't stamp drawings. You do.