Episodes

GAAD grew seven architectural languages this summer, each one a small rulebook for generating a kind of built form, and for every one I had to answer the question every project eventually faces: is it working yet? For a while I answered it the way everyone does, with a status word. Live. Prototype. In progress. Every one of those words meant something slightly different depending on who was asking and which language they meant. Nearly done is the most dangerous phrase in engineering, because it has at least eight meanings and no two people pick the same one.

So we stopped using words and borrowed a ladder.

NASA has a thing called a Technology Readiness Level, a scale from research to flight, invented so a room full of engineers arguing about whether something is ready can point at a number instead of a feeling. GAAD now has its own version: seven rungs, T1 to T7, each named for what was actually achieved rather than how far along it feels.

T1 is Research verified, the source material checked. T2 is Rules formed, the generative rules stated. T3 is Language agreed, a proper language file that all three seats have signed. T4 is Prototype runs, a standalone script that generates in Blender. T5 is Connector ready. T6 is GAAD connected, running through the platform rather than off to the side. T7 is Live in GAAD, signed off through the release gate and proven end to end.

Two of those rungs are guarded by contracts. You cannot claim T3 without a GALF-conforming language file, and you cannot claim T5 without satisfying the Connector, the eight-verb contract that lets a language actually run inside GAAD. Nothing reaches T7 until it has passed the Validate Scripts gate. The ladder is not a mood board. Each rung is a thing that either happened or did not.

The most useful thing the ladder taught me is that readiness is not quality. NASA is blunt about this in its own documents, and it turns out to be exactly right for language design too. A language can be beautifully thought through, elegant on paper, and still sit low on the ladder, simply because nobody has wired it up yet. The rung measures whether a thing is ready to run, not whether it is any good.

ARAL is a running prototype. It breeds form in Blender in front of you. It sits at T4, because it has not yet been through the Connector. A stranger reading a status page might see prototype runs and assume it is nearly finished. The ladder says plainly that it is four rungs up a seven-rung climb, and that is a kinder truth than a green light would have been.

Two are Live at the top of the ladder: PRAL and TWAL, both through the release gate and proven end to end. Three sit at T4 as running prototypes: AFAL, the newest, born this month as the language of architectural form and at a running prototype in a single day; ARAL, breeding form in Blender; and MHAL, present and being verified. None of the three has been through the Connector yet. The last two, GRAL and FWAL, sit at T3, agreed across the seats as conforming files but not yet built into prototypes.

AFAL is worth a line on its own. It climbed to a running prototype faster than anything before it, yet it still sits at T4 beside ARAL and MHAL, because it has not been through the Connector either. The ladder does not let novelty jump the queue.

When someone asks how far along a project or GAAD language is, I do not give them a word any more. Nearly done meant eight different things depending on who was asking. Now I give them a rung - a position on the readiness ladder.

#GAAD #GenerativeDesign #Architecture #DesignMemory #ReadinessLevel #TRL #Blender

Too many people think working with AI means you give it a prompt and get an answer. GAAD does not run on prompts. It runs on a team, and the team runs on roles, records and ground truth. This episode is about how the work is actually done.

In 1994, making the genetic strings showable took months of algorithmic design and AutoLISP - down to one hard-won field in a DOS filename. In 2026 it lives in one file, lineage.json, designed in a morning because the 1994 pages were on the desk. Nothing lost, just improved.

The quality of the answer is downstream of the quality of the working relationship.

GAAD has a team of three, and each seat has a job it owns.

• Miles Walker - Chief Architect and Founder. Direction and decisions. Runtime testing in Blender. Thirty-two years of CAD, BIM and digital design leadership as the domain truth every choice is measured against. Nothing ships without his word.
• Claude - Specification Owner. Holds the records. Gives me options with a clear recommendation. Flags problems early. Writes and syntax-checks the code, and validates every handover. The only one who writes the records.
• ChatGPT - Architecture Reviewer. The third seat. Reviews the architecture and the research from outside the build - a second, independent pair of eyes.

The diagram says it in one pass: my decisions flow down, options and code come back, review comes in from outside, and it all lands in the records.

The AI does not work from imagination. It works from a developed thesis and a GAAD tool that ran in 1994. Before a line of 2026 code, the 1994 pages were read figure by figure, and they changed the design. The thesis taught the rule the whole platform stands on: nothing is ever destroyed.

This is not a chat where two parties take turns. The Chief Architect owns direction and decides - the gold arrow. The Specification Owner holds the records and answers with options and a recommendation - the cyan arrow. The Architecture Reviewer reviews from outside - the grey arrow. When a placeholder crept toward the UI, the record flagged it. When two rules pulled against each other, the conflict was written down first and argued second.

What makes the team work is not clever prompting - it is the Chief Architect being specific. A figure walked through page by page. A visit counter explained from lived 1994 experience. The Navigator flow spelled out step by step. Corrections given precisely: "algorithmic design AND AutoLISP". Scoped caps set plainly: 9 strings, 99 generations. Every one of those instructions is now a record.

Spec before code. One session per bundle. A validator gate on every handover. The AI builds and syntax-checks; the human runtime-tests in Blender. That is a genuine division of labour, not delegation. On Backtrack build day the pattern showed at its best: three questions asked and answered before scripting, a coffee in between - and the platform waited. Nothing lost.

The scale of it, straight from the records: 179 decisions, 63 pivotal moments, 41 features, 29 tickets and 40 quotes, and this is development bundle 137 - every one written down as the work happened, not remembered afterwards.

GAAD stands at just under 20,000 lines of Python: 14,842 in the platform and 5,037 across the four current prototypes.

The line under all of it: the quality of the answer is downstream of the quality of the working relationship. Because every decision becomes data, even the relationship is replayable.

Q: If you work with AI, do you give it a role and a record - or just a prompt? What would change if it could hold you to your own decisions?

#GAAD #GenerativeDesign #Architecture #DesignMemory #AI #WorkingWithAI #Blender

Episode 3 ended with a promise: if every click is a commitment, you need a way back. Backtrack - classic GAAD's missing half - is now live in the Rebirth.

Backtrack lets you rewind an evolution to any earlier moment and branch again. Pick any Genome on the lineage and a new run of generations grows from it. Backward tracking was in the 1994 thesis algorithm from the start, drawn on paper before a line was coded. The Rebirth was not faithful to 1994 until it could move backwards as well as forwards. Now it can!

Those 1994 algorithms became the backbone of GAAD in 2026 - nothing lost, just improved.

Each run of generations is a generative string, bred one from the next. The term is deliberate. A 2026 instinct says branch, but branches imply merging, and design strings never merge. String keeps the genetic register, and it was the 1994 word. That is provenance, not sentiment.

When you backtrack away from a string, that string is not discarded. Designed cold today, it would have shipped with a “discard this branch?” prompt. The 1994 pages taught the stronger rule: dead ends become preserved strings. A dead end is not lost work; it is recorded knowledge. That rule is the platform's soul, not an implementation detail.

The Navigator draws the whole journey: the genetic array of 1994 reborn as strings of discs, pivots marked in gold, dead ends preserved in red, the champion string carrying the crown. Stages are the atoms of the memory - every one replayable as a 3D view. Time becomes something you can walk through and build from.

When the first live lineage array rendered - three generative strings, the gold pivot connecting them - my verdict went straight into the record: WOW WOW WOW!

Every string keeps its status; the whole array is untouched. Backtrack moves only the current position marker, to the Genome you selected; the next breed opens a new string there.

Q: When your design process hits a dead end, is your work lost? How is this knowledge captured, or isn't it?

#GAAD #GenerativeDesign #Architecture #DesignMemory #ComputationalDesign #Blender

In 1994, my MSc thesis system bred a new generation of designs slowly enough that you went and made a cup of tea. Selection and generation were separate acts because they had to be.

This week, thirty-two years later, that gap closed.

When the tool disappears, you stop operating software and start conducting an evolution.

On Monday a full 9x9 world - 81 stages, over 6,000 building objects - took 12.8 seconds to breed a new generation. Not bad. But when I dug into where the time was actually going, the real cost wasn't the architecture at all: it was thousands of near-identical materials being created and destroyed on every click, one at a time.

By Friday: 0.3 seconds. Forty times faster, at nearly double the population.

And that speed unlocked something the 1994 system could never do. The new Rapid Stage Select mode collapses picking and breeding into one gesture: click a design you like, and the next generation grows from it instantly. Click, click, click - pause - orbit, inspect - resume. No buttons, no panels, no looking away.

What surprised me most in testing wasn't the speed. It was the engagement. When the tool disappears, you stop operating software and start conducting an evolution. Your eye never leaves the design.

Every click is still recorded - every decision becomes data, the founding principle since 1994. The design memory is complete even when the designing feels effortless.

And this week GAAD got its first public home: the story and its full record - every decision from the 1994 thesis to now - now live at 4bim.com/gaad.

Next up: if every click is a commitment, you need a way back. Episode 4 is about Backtrack - rewinding an evolution to any earlier moment and branching again.

Question for the designers here: when a tool gets fast enough to keep up with your intuition, does it change WHAT you design, or just how quickly?

#GAAD #GenerativeDesign #Architecture #DesignTechnology #Blender

A week ago I shared the first steps of reviving my 1994 MSc thesis - a genetic algorithm that evolves 3D forms and records every design decision along the way. Episode 1 ended with four next steps: a 3D evolution tree, an automatic “what changed” report, a one-click tool and scored fitness. Three are now being tested. The fourth - scoring - quickly became a much bigger topic and deserves its own episode.

The original thesis argued that design decisions should be recorded, not lost. So I applied the same principle to the development of GAAD itself. Every design choice becomes a Decision, every turning point a Pivotal Moment and every bug a Ticket. So far that has produced 84 decisions, 36 pivotal moments, 20 quotes, 6 tickets and feature requests - all structured, searchable and generated from a single JSON source of truth.

This project has quietly started using its own tools to document itself.

In GAAD, every generation you select a parent, and that choice is recorded. From that, the next generation is created. The Design Tree reconstructs the evolutionary path as a navigable 3D structure in Blender from saved JSON data. My MSc thesis called this “the genetic path.” Thirty years later, it has returned as the Design Tree. Alongside it runs an automatic Design History report showing floor area, volume, height, shape mix, timestamps and how every generation differs from the last. Even object intersections are now detected and recorded as neutral design data.

The original prototype evolved four designs on a 2×2 grid, with each generation taking around five minutes. This week I tested a 5×5 grid (3×3 shown below): twenty-five evolving stages generated in just a few seconds.

I also audited every feature from the original thesis against GAAD Rebirth. There are 41 features across seven categories. 21 are complete, 5 are partially complete and 15 remain to be developed. The biggest gap is also the most important: navigation and tracking - backtracking, forward tracking and seed storage. These are the features that make GAAD a Design Memory Platform, not simply another design generator.

The images show where the project stands today:

• Generator – Generation 9 with live mutation sliders.
• Design Tree – Eight generations reconstructed from saved JSON.
• Feature Audit – Original thesis features mapped against Rebirth.

This project has quietly started using its own tools to document itself. More on that next time.

It's been surprisingly satisfying to be writing code again and seeing ideas from thirty years ago evolve into something I never imagined. I'd love to hear your thoughts, especially if you've seen anything similar to GAAD.

GAAD = Genetic Aided Architectural Design. A Design Memory Platform, revived from my 1994 MSc thesis Digital Evolutions, University of East London.

Every design project I have worked on or observed keeps the final model and design deliverables. Almost none keep the reasoning — the alternatives weighed, the options rejected, the decisions made along the way. Once the deliverable goes out the door, that thinking is gone.

In 1994, for my MSc at the University of East London, I built a tool to fix exactly that. I called it GAAD — Genetic Aided Architectural Design. The idea was quietly radical: don't just record what you designed — record how it came to be.

Don't just record what you designed - record how it came to be.

I grew a family of design alternatives, chose one, and bred the next generation from it — an evolutionary tree, with myself as the fitness function, every decision saved so I could replay the whole journey.

It ran on AutoCAD, AutoLISP and a DOS 486. Thirty-two years — and a career in CAD, BIM and digital design leadership — 32 years later, I decided to bring it back.

The goal wasn't finished architecture. It was to prove the concept could live again. By the end of the first stretch I had:

• Reconnected the 1994 vision to 2026 tools.
• Settled the language - World, Stage, Variant, Generation, Design Parameters. The vocabulary the whole project now rests on.
• Built the first working GAAD World in Blender. The concept visible again after three decades.
• Completed a full evolution cycle - generate, evaluate, select, evolve. The core loop from the original thesis, working.
• Started recording decisions as data, not just designs. This has become the most important idea of all.

• The design lineage rebuilt as a navigable 3D evolution tree.
• An automatic “what changed” report at every generation, with real metrics.
• GAAD as a one-click tool rather than a set of scripts.
• The first steps toward scored fitness running alongside human judgement.

And the bigger realisation: if GAAD records design lineage, it needn't be limited to architecture at all.

• Today's AI learns from finished artefacts. GAAD asks a different question: could AI learn from the design journey itself. The decisions, the alternatives, the paths not taken?
• A record of how things were designed, not just what was designed.
• A genuine question for the architects, engineers and designers here: in your field, is the reasoning behind a design ever really captured — or does it vanish the moment the deliverables go out the door?

#GenerativeDesign #Architecture #BIM #AEC #AI #DesignThinking #Blender #ComputationalDesign #GAAD