Mega Data: Turning a Company's Accumulated BIM Models and Drawings into AI-Ready Data for Generative Design
For a while now, my generative design (GD) work has fed AI with data that GD makes for itself. It works as a source of labels — GD knows the right answer for every design it generates — but the AI in that loop never meets a real model or a real drawing. The bigger fuel is already sitting in every company's archive. I call it mega data, and this series is about turning it into material a GD–AI loop can actually use.


What I mean by mega data
By mega data I mean everything a company has already built: the models and drawing sets of every past project. Nobody can read all of it by hand — so it has to become something a machine can read. It sits in three piles:
- BIM models (RVT). Rooms, equipment, parameters — inside proprietary files, named by each team's habit.
- Exchange models (IFC). The same buildings in an open format. A file can be valid and still be incomplete.
- Drawing folders (DWG / PDF). Sections, dimensions and notes, stored as lines and text rather than data.
None of it is AI-ready on day one. In this series, AI-ready has a narrow meaning: every item can be found, read, counted, and traced back to its source. It is the same point I made in Why AI in AEC Stalls: the problem is not a lack of data, it is a lack of structure.

Here is what “structure missing” looks like on a real project: a tunnel model that is geometrically complete, with nothing in it linked back to the spreadsheet that defined it.

And this is what one item looks like once it is AI-ready: one room from the public sample, as a Revit add-in exports it (excerpt; the shape is stored as a JSON string and decoded here, coordinates rounded). A name, a level, an ID that points back to the model element, and a boundary with its holes. All 54 rooms in the sample came out this way, 0 invalid.
{
"Room_Name": "Live/Work Unit 407",
"Room_Number": "407",
"Level": "L4",
"Room_ID_Auto": "830682",
"SourceFile": "Snowdon Towers Sample Architectural.rvt",
"RoomShapeJson": {
"unit": "ft", "boundary_mode": "EVEN_ODD",
"loop_count": 3, "loop_roles": ["Outer", "Hole", "Hole"],
"loops": [[{"x": 4.073, "y": 1.5, "z": 32.167},
{"x": 4.073, "y": -11.708, "z": 32.167}, …], …]
}
}
Loop 1.0 ran on synthetic data
Earlier I wrote that generative design can become a synthetic data factory: GD produces thousands of designs, and because GD built them, the labels come for free. It is a clean way to train a model — but the model only ever sees GD's own world.

Accumulated data enters the same loop at three points:
- Starting points. A past design seeds the next GD run instead of a random start. Lab Notes #7 showed this at small scale, with a design from another site.
- Rules. Judgments the AI keeps making the same way on real drawings become engine rules that run without AI — that is how real drawings become material the loop can read.
- Validation. A reader trained on synthetic sheets has to prove itself on real ones.


From pile to material: six steps
Every chain I have built for this — from folders of Revit models and from folders of drawings — ends up with the same six steps:
- Gather — take the folder as it is, convert formats, fingerprint (hash) every file.
- Split — a model into levels and rooms; a drawing file into sheets, a sheet into views and dimension marks.
- Read — coordinates, areas and dimensions come from geometry, never from a guess.
- Judge — names, types, duplicates, mismatches. By rule where a rule exists; by AI, citing the source element it judged, where it doesn't.
- Reconcile — every input is accounted for, and a person confirms the points where a wrong answer would cost money.
- Use — library rows, section parameters, models: the material.
The short version: code measures, AI judges with evidence, people confirm.

On drawings anyone can open. I ran the same drawing engine, unchanged, on the Civil sample sheet set that ships with AutoCAD. It counted every file (17 scanned = 14 drawings + 3 other), converted all 14 to DXF, and found 28 “sheets” — for a set of 10. The ten sheet files came out as one sheet each. The four shared reference files that the sheets pull in did not: one base drawing was cut into 14 “sheets” because its closed outlines looked like sheet borders, the title-block file became 2, and the other two were counted as sheets of their own. It is the same splitting failure as the unseen batch described below — which is why splitting sheets is the next thing to fix.

Count everything
One rule makes the rest auditable: every input lands in exactly one bin — used, duplicate (kept apart), failed with a reason, or waiting for a person. If the bins don't add up to the input, nothing is exported. Silence is not success.
On the public sample, the room export reports 54 rooms in, 54 valid shapes, 0 invalid. Field runs are messier — and that is the point: a failed bin with reasons is where the next fix comes from.


Two sources, two different jobs for AI
BIM models. AI doesn't read the RVT files. It writes the reader — a Revit add-in that extracts rooms and equipment from whole folders of models — and then fixes that reader from the logs the field sends back. Three field rounds so far: the first kept “same name, different family” apart instead of overwriting it; the second turned silent misses into a sheet of reasons; the third added per-element guards, so one bad element no longer stops a whole file. I wrote about this way of building add-ins in AI-Assisted Revit Add-in Development.
Drawings. Here AI judges first, and its repeated judgments become rules. On the road-project set the rules were written from, rules alone agreed with the AI's region judgments in 63% of regions, then 85%, then 92% as more judgments became rules. Then I ran the engine, unchanged, on a batch it had never seen. It broke at the Split step: an architectural set of 23 sheets was split into 59. That failure is now the first task of the next round — which is exactly what an unseen test is for.


Where the bridge stands
Honest status, because this series is a journey rather than a finished product:
- Archive → material: working for models; partly for drawings.
- Material → GD: working in places. In one large industrial program, equipment data from a previous phase already seeds the next phase's layout runs, and a set of measured real tunnel sections checks my section engine.
- Material → AI learning: not started. First comes a pre-registered test (pass criteria fixed before the run) of whether learning from this material is needed at all — if a rule or a fast simulation answers in time, no model gets trained.

The series
Part 1 makes the material, Part 2 feeds it into the loop, Part 3 is about running the chain day to day. Only 2-2 is already published; the cards link to the posts and papers each part builds on.
- 1-1 Folders of RVT models → an add-in → a library (coming)
- 1-2 Counting what's usable: IFC validation (next — based on our Buildings paper)
- 1-3 Drawing folders → an information model (after the next unseen test)
- 2-1 Rules first: optimization-ready layouts (coming — based on our Applied Sciences paper, with motion graphics)
- 2-2 Simulation as the judge (already published — the flood series · Lab Notes #5 · #6 · #7 · #8)
- 2-3 The bridge: an archive-fed loop (when it runs)
- 3-1 Code measures, AI judges, people confirm (coming)
Resources
- W. Cho, M. Im, Y. Hwang, J. Lee. Rule-Based Geometric Placement and Optimization-Ready UV Parameterization for Generative Facility Layout Design in BIM Environments: A Proof-of-Concept Preparation Methodology. Applied Sciences 16(20), 10408, 2026. doi:10.3390/app162010408
- J. Lee, C. Park, W. Cho, H. S. Choi. Coverage-Accounted, Provenance-Aware Validation of IFC Building Models for Public Safety Management. Buildings 16(21), 4263, 2026. doi:10.3390/buildings16214263
- Earlier posts: Generative Design in AEC Can Become a Synthetic Data Factory · Why Rules Matter in Generative Design for Water Treatment · Why Generative Design Needs Real Optimization Logic
- Tools used across the series: Revit API add-ins, Dynamo, NVIDIA Warp for GPU simulation.
What is sitting in your company's archive — and what would you want an AI to do with it first?
댓글
댓글 쓰기