Dynamo and C# plugins for Civil 3D and Revit with AI: how to build them 10x faster with Claude

What DOES change:

• Writing the first draft of code is 10x faster. You describe what you need in plain language, and it gives you working C#.
• Learning the API gets easier: ask it to "explain FilteredElementCollector" and you get clear examples.
• Debugging — paste the error message and it translates it into a plan of action.
• Exploring alternatives — "can this be done with less code?" — you get 3 options.

What does NOT change:

• You still need to understand what you're asking for. If you don't know what a Transaction is in Revit, the AI will hand you code that compiles but doesn't work.
• You need to test it on a real model. The AI doesn't have your model open.
• You need to decide the architecture of a large project. The AI builds the pieces, you design the puzzle.
• You need to take responsibility — if the code deletes the wrong element, it's your name on it, not Claude's.

What you need installed before writing your first line:

1. Visual Studio Community 2022 (free, visualstudio.microsoft.com). During install, choose the ".NET desktop development" workload.
2. Revit / Civil 3D — whichever you already use.
3. Revit / Civil 3D SDK — Google "Revit SDK 2024 download" or find Autodesk's official installer.
4. Claude or ChatGPT (Pro version recommended for long conversations, but the free tier works too).
5. A project template: there are free official Autodesk templates. They save hours.

For Dynamo, setup is even simpler: just install Dynamo (it ships with Revit and with Civil 3D as a package). Nothing to compile.

The difference between a good prompt and a bad one is hours of work. Golden rule: the AI doesn't guess your context.

Bad prompt:

"Make me a plugin to rename stuff."

Good prompt:

"I need a C# command for Revit 2024 that:

• Takes all views of type Section and Elevation.
• Renames them using the format: <ShortType>-<Level>-<Number>, where Number is sequential per level.
• Skips any view that already matches the format.
• Uses a single Transaction. Give me the full IExternalCommand code with error handling."

The second one has context (version, exact category, format, edge cases, expected pattern). The code the AI returns compiles and works on the first try far more often.

Structure of an effective prompt:

1. What software and version (Revit 2024, Civil 3D 2024).
2. What it should do, in detail.
3. What elements it touches (categories, exact types).
4. Edge cases — what happens if nothing is found, if the name already exists, etc.
5. Output format — full code, with imports, with transactions.

The honest list:

• Outdated API. Models sometimes use methods that no longer exist or changed between versions. Fix: paste the link or snippet from the official docs into the chat when in doubt.
• Business logic bugs. If your rule is "beams shorter than 3 m don't count" and you never said so, the AI won't guess it.
• Performance on huge models. The AI's code works fine on your 500-element test model. In production with 200,000 elements, it can freeze. That takes optimization.
• Distribution — .msi installer, digital signature, updates. AI can get you started, but it needs human judgment.
• Security — if the plugin deletes elements, does it have "undo"? Does it ask for confirmation? That's UX design, not pure code.

The pattern mixed teams use today:

Step by step:

1. Idea: "I want to automate renaming families."
2. Prototype in Dynamo: fast, visual. In 1-2 days you have something working. Show it to the team and check if it's what they need.
3. If no one is going to use it: you just saved a week of C#. Save the .dyn, move to the next problem.
4. If a lot of people will use it: ask Claude to port the Dynamo graph to a C# add-in. Paste in the graph logic (or explain it in words) and it hands you the base code. You polish it.
5. Package it as an .msi plugin with an installer. Distribute it to the team.
6. Keep the original .dyn as an "executable spec": if you need to change the logic tomorrow, iterate in Dynamo first, then regenerate the C# with AI.

That workflow reduces "development risk" — you don't sink 3 weeks into something nobody ends up using.

You don't need to be a software engineer. You need 5 habits:

a) Clear names. RenameViewsButton is better than Button1. The AI respects what you tell it; if you say "use clear names," it does.

b) One file per command. Don't cram 8 commands into one giant file. One per file (RenameViewsCommand.cs, ExportQuantitiesCommand.cs). Makes it easier to see what does what.

c) Backup with Git — no drama. Install GitHub Desktop (visual interface, zero terminal). Create a private repo. Every time something works: "Commit → Push." If you break something tomorrow, roll back with one button. Cost: 20 minutes to learn. Value: infinite.

d) Short comments where they matter. Don't comment the obvious. Do comment odd business rules: // Steel beams under 3m don't count per internal standard. Future you will thank you.

e) Test on a small model first. Before running against a real model, duplicate it and test. Always.

Signs it's time for expert help:

• 10+ people use your plugin and you can't keep up with bugs and requests.
• You start hitting errors that AI can't solve after 3-4 iterations.
• You need integration with external systems (a corporate database, ERP, enterprise authentication).
• You need professional distribution with a signed installer.
• Your scripts are starting to feel impossible to maintain.

What to expect from serious mentorship:

• Review of your current code and a refactor into something maintainable.
• Being taught patterns so future plugins are simpler.
• Professional setup: Git + CI + tests.
• A growth roadmap — so you don't depend on the mentor forever.

Good mentorship is an investment that makes you autonomous, not dependent.