Developing Revit add-ins with generative artificial intelligence

Despite shortcomings, models like ChatGPT, Gemini, and Claude serve as excellent co-pilots, providing relevant information and working code samples for tasks such as developing Revit add-ins.

There is great potential for the use of generative artificial intelligence within the AEC community for ideation, creation and automation. Although models such as ChatGPT, Gemini and Claude are far from perfect, they serve as great co-pilots that collate contextually relevant information and produce working code samples. So we’ll look at:

• creating code samples for a simple Revit add-in with ChatGPT
• the limitations and blunders
• the role of generative AI as teacher

Generative artificial intelligence is the flavour of the month it seems...

It sure is. Competitors such as Anthropic's Claude are joining established players such as OpenAI's ChatGPT and Google's Gemini to develop increasingly sophisticated systems trained with more parameters and with larger context windows.

How does this relate to developing Revit add-ins?

As programming languages and code are text based, they are a perfect area for text-trained generative AI to provide solutions to programming problems. In fact, Github Copilot claims to increase developer productivity by 55% - so it's not just about providing answers, but increasing development speed.

How do you get started?

Let's say we want a Revit add-in to tell us whether all the CAD links/imports in the project are pinned or not (so they don't accidentally get moved). We would prompt the generative AI system that we're developing a Revit add-in and explain in detail the functionality of the tool. For example:

I'm developing a Revit add-in in C#. Give me code that will see if all CAD links/imports in the project are pinned or not. Show me a message with the IDs of CAD links/imports that aren't pinned.

Cool, then what?

Here's the response from ChatGPT that you could copy and paste:

using System;
using System.Collections.Generic;
using Autodesk.Revit.ApplicationServices;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI;

namespace RevitAddin
{
    public class CheckCADLinksPinnedCommand : IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            UIApplication uiApp = commandData.Application;
            UIDocument uiDoc = uiApp.ActiveUIDocument;
            Document doc = uiDoc.Document;

            // Get all CAD links/imports
            FilteredElementCollector collector = new FilteredElementCollector(doc);
            ICollection<ElementId> cadLinks = collector.OfClass(typeof(CADLinkType)).ToElementIds();

            List<string> unpinnedCADLinksIds = new List<string>();

            foreach (ElementId cadLinkId in cadLinks)
            {
                Element cadLink = doc.GetElement(cadLinkId);
                if (cadLink != null)
                {
                    // Check if CAD link is pinned
                    if (!cadLink.Pinned)
                    {
                        unpinnedCADLinksIds.Add(cadLink.UniqueId);
                    }
                }
            }

            if (unpinnedCADLinksIds.Count > 0)
            {
                // Display message with unpinned CAD links/imports IDs
                TaskDialog taskDialog = new TaskDialog("Unpinned CAD Links/Imports");
                taskDialog.MainInstruction = "The following CAD Links/Imports are not pinned:";
                taskDialog.MainContent = string.Join("\n", unpinnedCADLinksIds);
                taskDialog.Show();
            }
            else
            {
                TaskDialog.Show("Pinned CAD Links/Imports", "All CAD Links/Imports are pinned.");
            }

            return Result.Succeeded;
        }
    }
}

That seemed easy. So is there a catch?

These systems can still produce erroneous code that would need to be debugged by a human. For example, code samples might refer to methods that don't exist within the Revit API.

Human jobs are safe for now then!

For now at least. Remember, these systems are only getting 'smarter' as they are refined and hardware continues to develop. It's likely that some jobs may experience a transformation in how their tasks are completed.

Oh, do tell...

For example, dimensioning construction documentation may be a thing of the past with products like Swapp and humans might be 'auditors' of AI generated work. Similarly, code developers might leave the bulk of coding work to AI copilots and be 'auditors' of code samples. Although experienced staff may easily spot errors in AI generated work, less experienced staff will appreciate that there's much to learn from our AI copilots.

That's a good thing, right?

Right. In addition to providing code samples, these sophisticated systems can also explain and comment on the code, effectively teaching you how to code. If you had to wait for a senior colleague to assist you with your work, or get an instant response from a chatbot (without the awkwardness human interactions can bring), you might be more inclined to rely on AI systems as your first go-to.

It all sounds promising...

Yep, and the AEC industry would always benefit from a helping hand.