Bozzetto — How to Use

Last Updated: January 1, 2026

Bozzetto adds a panel of seven buttons to the Avant Leap tab in your Revit ribbon. Each button opens a dedicated window for a specific part of the Zero Touch Node workflow — from searching existing packages, to designing and generating new nodes, to optimising and migrating existing code.

Buttons at a Glance

Button Label What it does
1 Search Nodes Search local packages, the Dynamo Package Manager, and a curated semantic index — returns a reuse-or-generate recommendation
2 Create Package Scaffold a new ZTN project from scratch: folder structure, .csproj, pkg.json, and a starter class
3 Plan & Build Describe a multi-node goal, review a diagram of proposed nodes with named input/output ports, then generate all C# at once
4 Add Node Generate a single C# Zero Touch Node and append it to an existing package
5 Optimize Point Claude at any ZTN .cs file and get an improved version with a side-by-side comparison
6 Migrate Update an existing ZTN package folder to a newer target Dynamo version
7 Settings Store your Claude API key, default output path, and version preferences

Before You Start

Complete the following steps the first time you use Bozzetto. You only need to do this once.

  1. Obtain a Claude API key from console.anthropic.com. Creating an account is free. Usage is billed by Anthropic per token consumed — Bozzetto itself has no backend cost.
  2. In Revit, go to the Avant Leap tab on the ribbon and find the BOZZETTO panel.
  3. Click Settings.
  4. Paste your Claude API key into the Claude API Key field.
  5. Set your Default Output Path — the root folder where new ZTN packages will be created. Choose a folder you use for local Dynamo package development (e.g., C:\DynamoDev\Packages).
  6. Set your Dynamo Version preference. This pre-fills version dropdowns in the Build and Migrate workflows.
  7. Click Save Settings.

Your API key is stored on your local machine in %APPDATA%\AvantLeap\Bozzetto\settings.json. It is never sent to AvantLeap.

Core Workflow

The standard Bozzetto workflow follows this sequence for building a new node:

Search Nodes → (reuse recommendation)
      |
      |── Green banner: existing package found → review and install from Package Manager
      |
      └── Blue banner: no strong match → Open Build
              |
              ├── Create Package (first time for a new package)
              │       └── Plan & Build or Add Node (generate C# code)
              │                   └── save .cs to package → build in Visual Studio
              |
              └── Add Node (existing package) → save .cs → build in Visual Studio

Improve existing code:

Optimize → browse .cs file → review diff → save

Update an existing package for a new Dynamo version:

Migrate → browse .Source folder → select target version → apply

Scenarios

Scenario 1 — First use: discovering whether a package already exists

Context: You need a node that collects all rooms in a view and returns their names and areas. Before writing any code, you want to confirm no existing package already does this.

  1. Click Search Nodes on the BOZZETTO ribbon panel.
  2. In the search field, type: get all rooms with area in view.
  3. Press Enter or click Search.
  4. Bozzetto searches your locally installed packages (Layer 1), the Dynamo Package Manager online (Layer 2), and a curated semantic index of the 50 most-downloaded packages (Layer 3).
  5. Results appear in a list. Each result shows the package name, source (Local / Online / Index), and a brief description.
  6. A recommendation banner appears at the top:
    • Green banner: A matching package was found. The banner names the package and explains why it was recommended. Review it before writing anything new.
    • Blue banner: No strong match. The banner suggests generating a custom node.
  7. Click Why? next to any result to ask Claude why that package is relevant to your query. Claude explains the match rationale in a popup.
  8. If the green banner names a package you want to inspect, find and install it from the Dynamo Package Manager inside Dynamo.
  9. If the blue banner appears, click Open Build to move directly to the node generation workflow.

Expected outcome: You either confirm a reusable package exists (and install it), or confirm no strong match exists and proceed to generate a custom node. Either way, you have evidence for your decision.

Scenario 2 — Creating a new package and generating the first node

Context: The search returned no strong match. You want to create a new ZTN package called MyFirmRoomTools and generate a GetRoomsWithArea node as the first class.

  1. Click Create Package on the BOZZETTO ribbon panel.
  2. Enter the package name: MyFirmRoomTools (no spaces — the name becomes the folder name and namespace).
  3. Enter a short description: Custom Revit API nodes for room data extraction.
  4. Confirm the output folder (defaults to your Default Output Path from Settings).
  5. Click Create Package.

  6. Bozzetto creates the following structure on disk:

    MyFirmRoomTools\
├── bin\
├── dyf\
├── doc\
├── extra\
└── .Source\
    ├── MyFirmRoomTools.csproj
    ├── pkg.json
    └── MyFirmRoomTools.cs   (starter class with private constructor)

  7. Click Add Node on the ribbon.

  8. Click Browse and navigate to the MyFirmRoomTools\.Source folder you just created.
  9. In the description field, type: Get all rooms in the active view. Return room name and area as parallel lists.
  10. Click Enhance Prompt — Claude reads the description and proposes named input and output ports. Review the proposed ports: inputs might include view (optional) and the document; outputs might include roomNames and areas.
  11. If the ports look correct, click Generate Node — Claude writes the complete C# ZTN class.
  12. Review the code in the preview panel. Confirm the class structure: private constructor, static public method, XML doc <returns name="..."> tags for each output port.
  13. Click Save Node to write the .cs file to the MyFirmRoomTools\.Source folder.
  14. Open the .Source folder in Visual Studio or Rider and build the project. The compiled DLL is placed in MyFirmRoomTools\bin\.
  15. Load the package in Dynamo by adding its folder to the Dynamo package search path.

Expected outcome: A working ZTN package folder on disk, a generated and reviewed C# node class, and a clear path to compile and load the package in Dynamo.

Scenario 3 — Planning a multi-node system before writing any code

Context: You want to build a set of three coordinated nodes: one that retrieves rooms, one that retrieves doors in each room, and one that counts doors per room. You want to design the node breakdown — inputs, outputs, and naming — before generating any code.

  1. Click Plan & Build on the BOZZETTO ribbon panel.
  2. In the goal description field, type: Three nodes: GetRooms returns all rooms in the model. GetDoorsInRoom takes a list of rooms and returns door elements grouped by room. CountDoorsPerRoom takes the door groups and returns room name and door count.
  3. Click Propose Nodes — Claude analyses the goal and proposes a node breakdown.
  4. The canvas displays a diagram of the proposed nodes. Each node appears as a box with its class name, method name, and named input and output ports as labelled dots.
  5. Review the diagram:
    • Confirm port names match your intended Dynamo wiring (e.g., rooms output of GetRooms connects to rooms input of GetDoorsInRoom).
    • Check that output types look correct (list vs. single element vs. grouped list).
  6. Click Export Plan to save the node architecture as a Markdown file — useful for a code review or team discussion before any code is written.
  7. To generate each node, switch to the Add Node tab within the Build window.
  8. Browse to your target package .Source folder.
  9. Generate each node in sequence — the proposed port names from the plan pre-fill the description field for each generation call.

Expected outcome: A reviewed, approved node architecture diagram before a single line of C# is written. The plan is exportable for documentation or team sign-off.

Scenario 4 — Optimising code generated by another AI tool

Context: A colleague generated a ZTN C# node using ChatGPT, but the code has no null safety, uses deprecated API calls, and doesn't follow the ZTN <returns name=...> port label convention. You want Claude to review and improve it.

  1. Click Optimize on the BOZZETTO ribbon panel.
  2. Click Browse and select the .cs file your colleague provided.
  3. The original code appears in the Original panel on the left.
  4. Click Optimize — Claude reviews the code for:
    • Null reference safety (document, view, and collected elements)
    • Correct ZTN XML doc port labels (<returns name="portName">)
    • Revit API best practices (transaction management, FilteredElementCollector disposal)
    • Performance (avoiding redundant collectors, correct use of element filters)
  5. The improved code appears in the Optimized panel on the right.
  6. Review the diff. Claude's changes are visible by comparing the two panels.
  7. Click Save Optimized to write the improved code to a new file (the original is preserved), or click Overwrite Original to replace the source file directly.

Expected outcome: A reviewed, improved C# ZTN file that follows Dynamo conventions and is safe to compile and use in a production package.

Scenario 5 — Migrating an existing package to Dynamo 4.0

Context: Your firm has an internal ZTN package built for Dynamo 3.x. After upgrading to Revit 2026, the package fails to load because the engine version and NuGet references are outdated.

  1. Click Migrate on the BOZZETTO ribbon panel.
  2. Click Browse Folder and select the .Source folder of the package (the folder containing the .csproj file).
  3. Select your target Dynamo version from the dropdown: Dynamo 4.x.
  4. Click Migrate Package.
  5. Bozzetto updates the following in place:
    • engine_version in pkg.json (updated to the Dynamo 4.x compatible value)
    • NuGet package versions in .csproj (DynamoVisualProgramming.ZeroTouchLibrary, DynamoVisualProgramming.DynamoServices)
    • Build output paths in .csproj to match the Dynamo 4.x folder convention
  6. A summary of changes appears in the result panel, listing each file and each field that was updated.
  7. Open the .Source folder in Visual Studio and rebuild. Review any remaining compile errors — API call changes specific to your code require manual updates (the Migrate command updates structure, not bespoke API logic).

Expected outcome: An updated package .Source folder that compiles against Dynamo 4.x references. Manual follow-up may be needed for deprecated API calls within the node logic itself.

Tips

  • Search first, always. Even if you are confident no package exists, the 30-second search often surfaces a related package that covers 80% of the need. Use it as a baseline, not a gate.
  • Name ports clearly in your description. When you describe a node for Add Node, name the inputs and outputs explicitly: "inputs: document (optional), categoryName (string); output: elements (list)." Claude honours these names exactly.
  • Review generated code before saving. Claude follows ZTN conventions reliably, but always verify the output type, null checks, and transaction handling before compiling — especially for nodes that write to the Revit model.
  • Enhance Prompt before Generate. The Enhance step lets Claude refine your description and propose port types. Skipping Enhance and going directly to Generate often produces vaguer code. One extra click is worth it.
  • Export the Plan before generating. The Plan & Build export gives you a Markdown spec file. Send it to a colleague or lead for review before spending API tokens on generation — it is much cheaper to change a diagram than to regenerate code.
  • Use Optimize on existing code, not just ChatGPT output. Bozzetto's Optimize command is equally useful on code you wrote manually six months ago. Periodic review catches null safety issues that grow as the Revit API evolves.
  • Keep your output folder outside the Revit add-in folder. Generated packages should live in a dedicated development folder (e.g., C:\DynamoDev\Packages), not inside Revit's Addins directory. Dynamo loads packages from its own package paths, not from Revit's addin folders.
  • Trial resets if you delete settings.json. The 30-day trial period is tracked in settings.json. Deleting this file resets the trial — but also clears your API key and all preferences.