From Teaching Clicks to Leading AI Agents: How My Dynamo and Revit Class Changed in Two Sessions

I am teaching a special lecture series of five sessions at a university, and over the second and third sessions I stopped teaching Dynamo the way I had taught it until now. The students no longer follow my clicks node by node. They watch a concept, watch an AI agent apply it, and then review the result together with me. This post puts the two sessions side by side, because what changed was not the software on the screen but the way I teach and the way I lead the work, both the class and the agents in it.

In short

  • November 11: I gave one prompt to four AI coding agents. Wherever the prompt left a decision open, each agent made that decision on its own, and every decision about form sat on the geometry cycle we had practiced earlier in the same class.
  • November 18: the small graph I built in class became the prompt. While I kept teaching, an agent turned my 26-node graph into a 97-node Dynamo graph for a two-storey house without a single Python node, testing its builds four times in a separate copy of Revit.
  • After the second break we reviewed its work together, so the class now runs from concept to AI to joint review.
  • My own part in the work came down to four acts: specifying, permitting, stopping and starting, and reviewing.

The class I stopped teaching

Until now my Dynamo classes looked much the same from the back of the room. I clicked, the students clicked after me, and most of the time went into finding the right node and wiring it in the right order. On November 18, at the start of a recap demonstration, I told the students that there was nothing to follow along with today and asked them to simply watch where the flow was going. All quotes from the class in this post are my own translations from the Korean recordings.

Each row of the table below is backed by the class recordings, the agent logs or the material I handed out.

BeforeNow
I click and the students copy"There is nothing to follow along with today. Just watch how the flow goes."
Nov 18 recording
Students memorize node namesStudents are shown the AI button that newer Dynamo versions put next to a node input, which suggests the node to connect: "for the hard ones, use the AI feature to find them"
Nov 18 recording
My demonstration is the whole classMy demonstration and the agent's work run at the same time, and after the break we review the result together
Figure below
Students rebuild what they just learnedWhat they learned becomes the prompt: splitting the wall list by floor turned into "1st floor 3 m, 2nd floor 2.5 m"
Nov 18, minutes apart
The result is the student's own graphStudents read and review the AI's result, and can keep editing it with their own AI tools
Nov 11 student folder
Homework is hand practiceThe same practice with a new purpose: recognizing the geometry cycle inside AI results
Nov 12 homework mail
The class ends with how to use the softwareIt ends with careers: what clients ask for and what to do beyond automation
Nov 18 recording
Timeline of November 18 with a teaching lane and an agent lane, and the agent lane of November 11
  1. Nov 18, 15:49 the lesson graph and one paragraph
  2. 16:06 asks before opening a test Revit; approved 16:07, in the break
  3. 16:47 "stop verifying and wrap up"
  4. 17:12 "start": sketch to saved walls in 77 s
  5. Nov 11, 15:37 same prompt into four agents
  6. 16:17 agent C: fix its launcher
  7. 16:36 same three follow-ups to all four
  8. 16:40 .dyn requested only from B and C

On November 18 I taught in the upper lane while the agent worked in the lower one, and the two lanes met in the review after the second break.

November 11: one prompt, four agents

In the second session I taught the geometry cycle, Point › Curve › Surface › Solid › Surface › Curve › Point, and then pasted one prompt into four AI coding agents, two in Claude Code and two in Codex (OpenAI's coding agent), each isolated in its own folder so that no agent could see the work of another. The prompt asked for a tool for site and massing review with 2D and 3D views, rooms, floors and a generative design step, and all four agents chose on their own to build it as a browser app, and all four apps ran in the end. About an hour later I sent the same three follow-up requests to all four (a random freeform option, a check of the structure, and a tool for inserting voids), asked only B and C for a .dyn file that previews the alternatives in Dynamo, and asked C once to fix a launcher file that did not start.

Four web apps built from the same prompt, each switching between its own design alternatives

Four apps from one prompt. A and B were built in Claude Code, C and D in Codex. The interfaces are in Korean because the class was taught in Korean.

The four apps looked nothing alike, and the pattern behind the differences fits in a few lines. The single phrase "generative design" was read as optimization by two agents and as random variation by the other two. The curved floor outline of the freeform option was described with 96, 72, 40 and 48 points in the four apps. The floor was divided into grid cells, grown from seeds, sliced along an axis, or simply covered with rectangles dropped onto it. A request to check the structure became four different measurements, and only one of them calculated anything from loads.

Each step of the geometry cycle linked to a decision the AI made on its own

None of these choices broke the prompt, because the prompt never specified them. I had written what I wanted and left out how to build it, and each agent filled the gap with its own decision. Every one of the decisions about form sat somewhere on the cycle the students had practiced earlier in the same class, and for that reason I now see geometry as the vocabulary for talking to these tools rather than as a topic that AI has made obsolete.

November 18: the lesson became the prompt, and the agent worked in Revit

The third session moved into Revit. In the first period I showed that a Revit element is geometry as well. A wall returns a Solid through Element.Geometry and a line through Element.GetLocation, and that line is exactly the one you clicked when you drew the wall. The volume from Solid.Volume matched the volume in the Revit properties panel, both 9.744, and when I cut an opening into the wall both numbers changed together to 8.028.

From there we went the other way and made walls from lines with Wall.ByCurveAndHeight, then split the list of walls with List.TakeItems and List.DropItems so that the first three walls got one height and the rest another. I told the class that a two-storey house with a 3 m ground floor and a 2.5 m upper floor is nothing more than the wall list split by floor, with a different number for each part.

A minute later I saved that small graph of 26 nodes, and a few minutes after that I gave it to a Claude Code agent together with one paragraph. The last time I had asked an AI for a .dyn file, it had pushed nearly everything into Python script nodes, so this time I asked for basic nodes. The prompt, translated from Korean, read as follows.

I am going to automate modeling in Revit. This dyn file uses Dynamo's basic nodes to create walls. Based on this Dynamo file, use basic nodes to make a dyn file that builds the following. I am going to make a two-storey house. Make the first floor L-shaped and the second floor a rectangle. The first floor has a floor height of 3 m and the second floor 2.5 m. I used basic nodes for the walls, but please also make walls, floors, columns, beams and interior finishes with Dynamo basic nodes. If possible, doors and windows would be good too. Let me see your design ability.

Then we took a break, and the agent kept working through it and through the whole second period. During the break it asked me a question, and when class resumed I read it out to the students. It wanted to open a separate test copy of Revit instead of touching the Revit I was teaching with, to click "load once" in the security dialog only for one of my own add-ins that carries a self-test hook and "do not load" for everything else, and to leave every permanent setting unchanged. I had already approved exactly that scope, and I told the students it had become rather considerate lately.

The agent's question during the break (translated; the add-in name is replaced)

"I want to verify the dyn by actually running it in Revit 2026. May I open a separate test Revit (I will not touch your Revit) and, in the security dialog that appears there, click Load once only for [one of your add-ins with a test hook] and Do not load for the other add-ins? (No permanent settings change. One Revit window may look unresponsive during the test.)"

☑ Yes, click and proceed (recommended): verify in the test Revit up to creation, images and element counts, then report

☐ No, files only: only the dyn file and offline checks, I run Revit myself

With that permission the agent built and ran test versions of the graph in the test Revit four times and inspected the model after each run. Among the faults those runs exposed, three are worth showing students. The wall type width came back in feet instead of millimeters, a conditional in a code block that returned an empty list on one branch was repeated by Dynamo for every item of the list (replication), so that the finish walls and ceilings came out empty, and four large windows on the upper floor did not cut their walls although Revit raised no warning. The version it handed over adds a final step meant to fix those windows. That step had not been run in Revit when I stopped the agent, and when I later ran the graph in class I did not check the windows. At 16:47 I told it to stop verifying and wrap up, just under an hour after the prompt went in at 15:49.

The first fault is still visible in the graph the agent handed over, as a small code block that converts the width before anything uses it (comment translated):

// WallType.Width comes out in feet in Dynamo 3.6 (measured: a 297.5 mm wall gives 0.976), so convert to mm
tE1 = a < 50 ? a * 304.8 : a;
tE2 = b < 50 ? b * 304.8 : b;
tI = c < 50 ? c * 304.8 : c;
tL = d < 50 ? d * 304.8 : d;
Two-storey house in Revit: L-shaped brick ground floor with terraces and a rectangular upper floor

The house from the third test run in the test Revit. The level names are in Korean.

The final graph has 97 nodes in 11 labeled groups, 24 of them code blocks and none of them Python. The test builds also carried one or two extra Python nodes that dumped the model for inspection, and the graph the agent handed over leaves them out. In its third test run it created the walls, two floor slabs, a roof, ten ceilings, 28 structural columns, 58 beams, 15 doors, 14 windows, twelve named and numbered rooms and a stair modeled as a solid, with parapets on the roof and low parapet walls around the terraces.

Two Dynamo graphs drawn at the same scale: the 26-node class graph and the 97-node agent graph in 11 numbered groups
  1. Design variables: change a number and the house follows
  2. Types picked from dropdowns
  3. Levels and floor plans for 2F and roof
  4. Plan data: a module table and one formula
  5. Floors and roof
  6. Walls, with the same wall node as my class graph
  7. Columns and beams on a 3 m steel grid
  8. Doors and windows: one table row per opening
  9. Rooms: twelve, named and numbered
  10. Interior finishes: wall, floor, ceiling
  11. Stair and 3D view

My 26-node class graph and the agent's 97-node graph at the same scale, drawn from the two .dyn files (node positions, wires and groups as saved; box sizes estimated). Dark boxes are code blocks. Group titles translated.

From a rough sketch to walls

For the last demonstration I drew three rough rectangles in PowerPoint, took a screenshot and gave it to the agent, which read twelve line segments from the image and numbered them. I asked it to tell me when it was ready and to begin only when I said start. At 17:12 I said start, and in a visible test Revit it placed the image, drew the twelve walls one line at a time with a note showing which sketch line it was working on, switched to 3D, added three floor slabs and saved the file, 77 seconds after my start.

Three rough rectangles drawn in PowerPoint
The sketch
Twelve numbered line segments read from the sketch
Twelve lines the agent read
Walls built from the twelve lines in a Revit 3D view
The walls in Revit

I want to be exact about how this worked, because it is easy to misread. The agent did not move the mouse or click through the Revit interface. It ran a script inside Revit through the self-test hook in one of my own add-ins, which executes a Dynamo Python node and redraws the view after each step, so the class could watch the walls appear in order. That Python lives in my add-in, not in the house graph, which has none. No MCP server, a common way of connecting AI tools to applications such as Revit, was involved in either the house build or the sketch demo.

What I asked for, what the agent built, and why

My prompt was one paragraph, and the graph that came back does a great deal more than the paragraph asked. I want to put the two side by side before the review, because the gap between them is exactly the space my prompt left open. For this post I also wanted the reasons behind each addition and the order of the work. Instead of asking the agent to explain itself after the fact, I kept only what it wrote down during that hour: the README it left next to the graph, the notes and comments inside the graph, and the short messages it sent me while working. The order of the work comes from the session log of what it did. Where those records give no reason, I say so.

My prompt saidThe agent built (counts from its third test build)
"Based on this dyn file, use basic nodes"Kept my wall node, Wall.ByCurveAndHeight, and its dropdown for the ground-floor exterior opens on the same brick wall type my class graph uses. The graph has 97 out-of-the-box nodes and code blocks and no Python node, although the agent produced it with a Python script of its own that writes the .dyn file directly.
"A two-storey house"Two new levels at 3,000 and 5,500 mm, each with its own floor plan view.
"First floor L-shaped"An L of 108 m² on a 3 m grid, wrapped around a garden on the south-west side.
"Second floor a rectangle"A 9 × 9 m box of 81 m² set on the inner corner of the L and pushed 3 m out over the garden, so that it roofs the entrance porch, with one steel post at the free corner.
"3 m and 2.5 m"Both as input numbers. The ground-floor wall height is measured from the slab the graph has just created, 3,000 minus 211 = 2,789 mm.
"Walls, floors, columns, beams"20 walls for the two storeys, slabs extended to the outer face of the walls, and 28 columns and 58 beams on a 3 m steel grid, with columns only inside walls and at the porch corner.
"Interior finishes"48 thin finish walls (lining walls) around the rooms, all joined to the structural walls, and ten ceilings. Floor finishes are switched off by default because the template has no thin floor type.
"Doors and windows, if possible"15 doors and 14 windows, driven by one table row per opening: wall number, position along the wall, type.
"Let me see your design ability"A design concept described in its README: the garden, the porch under the box, terraces on the two leftover roofs, and a brick base under a box in a different finish.

On top of that, the graph contains several things my prompt never mentioned. There is a roof, ten parapet walls (four around the roof and six around the two terraces), twelve named and numbered rooms, an 18-riser U-shaped stair with its own opening in the upper slab, a 3D view looking down from the garden, a panel of design variables, and type dropdowns whose default values match the Revit template I use.

What its notes say about the additions

  • Rooms and finishes share one table. Each row of the room table holds a rectangle, a name and a number, the wall types on the four sides, and whether the room gets a ceiling and a floor finish, so the same row places the room and lays the lining walls along its sides. The notes do not say why it chose to add rooms. Before writing anything, it had also traced one of my own older graphs that builds wall, floor and ceiling finishes from rooms.
  • One number changes the whole house. The note on the first group and the README say that every plan coordinate is stored in grid modules, so changing the module, which the slider allows between 2,700 and 3,600 mm, scales the whole house in proportion.
  • Defaults that work in my template. Its messages say that it read the type names out of the template I had been using so that the dropdown defaults would match, and it later listed the real types in the test Revit before writing the design.
  • Steps that must wait for others. Its notes state the order of the dependent steps and how the graph enforces it. The wall height is measured from the slab that has just been built, rooms are placed only after all walls stand because the walls are wired into them as an input, and the window sill heights are written again at the very end, because Revit recalculates the cuts only when the value actually changes.
  • Checks before the house graph. The design data sits in its own file and is checked before the house graph is generated. The first check reported 12 and 9 square modules for the two floors, 108 and 81 m², and confirmed that the twelve rooms matched their walls one to one.

The order it worked in

The times below come from the session log on my computer. What surprised me is where the time went. Between 15:50 and 16:19 the work was about how to test the result, the file format of Dynamo nodes and what my template contained. The concept for the house shows up once in its messages at 16:01, and the design tables were written only at 16:20.

  1. 15:50 Looked for a way to run the graph in a real Revit without touching mine, and read the type names in the template I use.
  2. 15:54 Learned the exact file format of Dynamo 3.6 nodes from graphs already on my computer, and traced my older room finish graph.
  3. 16:01 Reported that it was settling on the concept: the 9 × 9 m box on the L, roofing the entrance porch.
  4. 16:06 Asked whether it could open a separate test Revit and answer its security prompts, and I approved at 16:07.
  5. 16:10 Ran a small probe graph in the test Revit to list the real types: 26 wall types, 5 floor types, one steel column type, one beam type, 5 door types and 6 window types.
  6. 16:20 Wrote the design as tables in grid modules and checked them.
  7. 16:22 Wrote the graph generator, and at 16:25, after fixing an error in it, generated the first graph with 93 nodes and 209 wires.
  8. 16:25 to 16:36 Ran three test builds in the test Revit. The faults described above were fixed along the way, but the third build still left four upper-floor windows uncut.
  9. 16:37 to 16:47 Investigated those windows with experiments on the saved model, then ran a fourth build with the openings reordered, which left the large ground-floor windows uncut as well. It then added a final step that writes the sill heights again, and this step had not been run in Revit when I stopped it.
  10. 16:48 Stopped at my request and saved the final graph of 97 nodes.

Inside the graph, the eleven groups run from left to right: variables, types, levels, plan data, floors and roof, walls, columns and beams, doors and windows, rooms, finishes, and finally the stair and the 3D view. I joked in class that one sentence about design ability had made it build far more than I needed. Its notes do not show that this sentence was the cause, but the comparison shows how much room a short, open prompt leaves.

Reviewing together: the new center of the class

After the second break we opened the graph and the model and reviewed them the way a Revit user would. This part of the class is where I think the teaching now happens, because most findings below needed knowledge of Revit and geometry rather than memorized nodes.

  • Basic nodes or not: the agent did use basic nodes, picking wall, floor, roof, ceiling and framing types from the regular type dropdowns.
  • Code blocks: it also used 24 code blocks. I showed the students Node to Code on two points and a line, so they could see that a code block is simply nodes written as text that the computer reads. My point was about who can fix what, since a Python node can only be fixed by someone who reads Python, while basic nodes can be fixed by anyone who can follow the lists. Some of its code blocks packed whole geometry steps into a single block of text, so having no Python did not automatically make the graph easy to read.
    One of them builds the whole U-shaped stair (comment translated; m is the grid module, e1 the ground-floor level, FH1 the ground-floor height and tFe the floor finish thickness):
    // U-shaped stair north of the ground-floor stair hall: 18 risers, riser = ground-floor height / 18, tread 260
    w = (m - 500) / 2;
    go = 260;
    ri = FH1 / 18;
    y0 = 4 * m - 200 - w - 8 * go;
    xa = 2 * m + 200;
    xb = 3 * m - 200;
    i = 0..7;
    z0 = e1 + tFe;
    za = z0 + (i + 1) * ri;
    sa = Cuboid.ByCorners(Point.ByCoordinates(xa, y0 + i * go, za - ri - 200), Point.ByCoordinates(xa + w, y0 + (i + 1) * go + 1, za));
    zl = z0 + 9 * ri;
    sl = Cuboid.ByCorners(Point.ByCoordinates(xa, y0 + 8 * go, zl - 250), Point.ByCoordinates(xb, y0 + 8 * go + w, zl));
    zb = z0 + (10 + i) * ri;
    sb = Cuboid.ByCorners(Point.ByCoordinates(xb - w, y0 + (7 - i) * go, zb - ri - 200), Point.ByCoordinates(xb, y0 + (8 - i) * go + 1, zb));
    stair = Solid.ByUnion(List.Flatten([sa, sl, sb], -1));
  • Categories: the stair was modeled as a DirectShape, a free-form solid placed in the Stairs category, which I praised, although no stair schedule had been made. When you extract quantities later, the category decides what a schedule counts.
  • Finishes: the columns had no finish, and because the exterior walls were compound walls with the brick as one layer, a strip of finish was left over at the slab edges. Modeling the structural wall and the brick as separate walls, with the brick carried past the slab, would have avoided this.
  • Chosen, not made: in class I praised the profile at the base of the brick walls. Checking the graph afterwards showed that the profile belongs to a wall type that already existed in the Revit template, a type with "Plinth" in its name, and that my own 26-node class graph had already selected it. The agent kept that type, but it did not build the profile, and telling apart what an AI made from what it kept is exactly the kind of review I want students to practice.
  • Errors: the first run in class stopped with an error, and opening the file again and running it a second time worked. I did not record the error message, so I cannot say what caused it.
Section through the generated house showing the U-shaped stair, two floor slabs and the roof

A section through the third test run: the stair, the two slabs and the roof with its parapet.

Ground floor of the generated house seen from above, with rooms, partitions, doors and the stair

The ground floor with the upper floor hidden: rooms, partitions, doors and the stair.

Leading the work: four acts

When I put both sessions side by side, my own part in the work of the agents comes down to four acts, and none of them is operating the software for them.

Nov 11: four agents, one promptNov 18: one agent in Revit
1. Specifying
I wrote only the what, so each agent decided the how. This led to the fill-in prompt template below.An example file (my 26-node class graph), one paragraph and a request for basic nodes produced 97 nodes and no Python.
2. Permitting
I isolated each agent in its own folder so that no agent could see another's work.The agent asked first, and I approved a narrow scope: a separate test Revit, my add-in with the test hook loaded once, no permanent settings.
3. Stopping and starting
The same three follow-ups went to all four at 16:36, and a .dyn request only to B and C at 16:40."Stop verifying and wrap up" just under an hour after the prompt, and a sketch demo that waited for my "start".
4. Reviewing
What did each "structure check" measure? Four answers, only one with loads.Code blocks, the stair category, the slab edges, and the plinth it kept rather than built.

Specifying is where the November 11 lesson came from, since anything I leave out of a prompt becomes a decision the agent makes for me. Permitting is the act I did not expect to write about at all. On November 18 the agent asked before acting, and my job in that moment was to decide how far it could go, not to do the work myself.

Stopping and starting sounds trivial, yet on November 18 the agent kept testing and fixing its graph until I stopped it, and the sketch demo did nothing until I said start. Reviewing is the act that needs the most knowledge, and it is the one where geometry, list structure and Revit categories matter most.

What students practice now

The skills I want the students to build have shifted from clicks to the words they give an agent and the eye they use to review its result.

  • The geometry cycle in both directions. A Revit element is geometry, and geometry can become an element again, so a wall gives you a Solid and a line while a line gives you a wall. In class I put it this way: "If you can move through geometry from front to back and from back to front, your thinking becomes flexible."
  • Prompts that state the how. The student pack includes a fill-in template, shown below, that turns the November 11 lesson into a habit, because anything you specify can be checked afterwards while anything you leave out can only be compared across results.
  • Finding nodes with AI. Node names are something you can ask for, while the structure of the lists is something you have to understand yourself.
  • The same homework with a new purpose. Students still repeat Point › Curve › Surface › Solid › Surface › Curve › Point ten times by hand, and now the exercise also trains them to recognize the same cycle inside the results an AI produces for them.
  • Continuing with their own AI. I bundled the four November 11 apps into one folder for the students. If a student opens the folder in their own AI tool and asks it to read AGENTS.md (a guide file written for AI coding tools) first, the guide documents inside help the AI understand the structure and keep editing from there, so the fifth result is theirs to build.
A prompt that states only the what, next to a prompt that also states the how in geometry terms
[What to build] ...
[How it runs] e.g. a single HTML file that opens on double-click / whether a local server is allowed
[External libraries] allowed / not allowed
[Core rules] e.g. rooms are rectangles, the core stays in the same place on every floor
[How to choose alternatives] e.g. daylight 40 · core access 30 · room shape 30
[Definition of done] e.g. automatically check that room + shared + core area on each floor equals the floor area
[Leave out] e.g. corridors, doors, code compliance
[Report] list what you verified and what you could not verify, separately

What I told the students at the end

I closed the third session with a few words about their careers, because a demonstration like this one can easily sound like a warning. I told them that nobody is asking them to stop learning Dynamo or Revit, and that people who draw in CAD are not falling behind, since they already earn their living with it by following the standards of their companies. Depending on the project, some clients still take delivery of a Revit model, some ask for AI automation add-ins, and some ask for IFC submissions.

I also admitted that I do not know how a fourth-year student should build a portfolio right now, because the technology is moving faster than any advice I could give. What I asked of them instead was simple. Do not conclude that Revit now models by itself and you can skip it, but understand how it works and think about what more you can do with AI on top of that understanding.

Earlier in the series I had shown them how hundreds of real project RVT files can be turned into data that an AI can actually read, which I wrote about in my mega data post. These two sessions are the other half of the same story, about what people do once the AI can read and act.

What this post does not claim

  • These are two sessions out of five, and each demonstration was shown in a single class. They show how a class can change, and they do not rank AI tools.
  • I did not measure learning. I have not compared students taught the old way with students taught the new way.
  • The agent worked only in a separate test copy of Revit under a scope I approved. I would not give the same freedom on a production model without more checks.
  • The final graph ran in class on the second attempt, but I did not check its windows, so I do not claim that it cuts every window correctly. The counts in this post come from the third test build.
  • The house demonstrates what a graph of basic nodes can build, and it is not a design checked against any code. The structure numbers in the November 11 apps are not a basis for structural design either.

The last two sessions

Two sessions remain, on November 25 and December 2. When the series ends I hope to write one more post about what the students actually did with the agents and what changed for them.

댓글

이 블로그의 인기 게시물

Structural Analysis Workflow with Dynamo and Robot

Dynamo with the Gemini Vision API test(Nano Banana)

Geometry test 0506 stair and routing