Hey, I'm Michael Kilkelly and welcome to the ArchSmarter podcast! In this episode, we're going to tackle a question I hear a lot these days: "Why should I bother learning to code when AI is going to do it for me?" You know what? It's a fair question. With tools like ChatGPT, Claude, and Gemini writing lines and lines of code, it might seem like programming skills are becoming unnecessary.
But here's the thing - I spent the last few weeks building a new Revit add-in called Launchpad, and the experience totally changed how I think about AI and programming. Let me share something wild: I built Launchpad in just two weeks with AI's help. This project easily would have taken me two months or more without AI. But here's the paradox - it actually required MORE programming knowledge, not less.
Before I explain why, let me quickly tell you about Launchpad. It's an interactive learning tool that teaches you about C# and the Revit API, and lets you write and run code directly inside Revit. Think of it as a safe playground for learning how to code in Revit. The irony isn't lost on me - I used AI to build a tool to help people learn to code. But that's exactly what helped me understand where AI fits in the future of programming.
One of my favorite books as a kid, and maybe one of the reasons I decided to become an architect (besides my obsession with LEGO), was "Cathedral" by David Macaulay. It's a picture book that illustrates the entire process of building a fictional Gothic cathedral. If you remember your architectural history, the master builder was the person who supervised the design and construction of these marvels. This was well before the days of contract documents, specifications, and code consultants. The Master Builder had to know how everything fit together - which tasks needed to happen in what order, how different craftspeople interfaced with each other, and most importantly, they could look at the work and know if it was done correctly.
The master builder tradition emerged during a time of great architectural innovation - the Gothic period was pushing boundaries with taller, lighter structures than ever before. The master builder had to deeply understand both design and construction to make it work. Sound familiar? We're in a similar period of rapid innovation with AI.
That's exactly what I think is happening today with programming. Coders aren't becoming obsolete - they're becoming the digital equivalent of the master builders. Just as a master builder didn't need to lay every stone but needed to understand masonry, modern programmers don't need to write every line of code but need to understand how software systems fit together.
Let me give you a specific example from building Launchpad. One of the key features is the ability to run C# code directly inside Revit. You don't need a separate development environment or to build your code as a .dll file - you just type in the Code Editor and click run. When working on this feature, I:
Had a clear vision of what I wanted to achieve
Understood how it needed to integrate with Revit
Could evaluate AI's suggestions effectively
Knew when code was getting too complex and how to ask for improvements
Could spot potential issues before they became problems
It was very much like being a master builder on a construction site. Instead of using a plumb line and chalk, I was reviewing and refining the code in Visual Studio. I wasn't writing every line myself, but my expertise and experience made the difference between a successful project and a hot mess.
This new way of working with AI completely transformed my development process. Instead of writing every method from scratch, I found myself operating at a higher level - more master builder than stone cutter. I'd provide context about what I was building, describe what I needed, and carefully review what AI produced.
The rapid prototyping aspect was particularly exciting. Because I wasn't investing days of coding time in each approach, I could experiment more freely. I'd implement an idea, test it thoroughly in Revit, then refine or reject it based on the results. This reminded me of how master builders would often sketch ideas full-scale on the building site, testing concepts before committing them to stone.
Let me share with you three crucial insights I gained from this AI first process:
First, vision and understanding are essential. Just like a master builder needed to conceptualize the entire cathedral before work began, I needed a clear vision for Launchpad before writing any code. AI could help implement features, but it couldn't tell me what would make for an effective learning tool. This is something I learned early in my architectural career - you can have the most skilled craftspeople, but without a clear vision of how everything comes together, you'll end up with a beautiful mess.
Second, quality control becomes even more crucial with AI. When building Launchpad's user interface, AI could generate code quickly, but I needed enough programming knowledge to recognize when something wasn't right. For instance, AI initially created an overly complex system for handling user input, with multiple event handlers and custom validation classes. Because I understood the fundamentals, I could spot this over-engineering and ask for a simpler solution.
Third, programming knowledge amplifies AI's capabilities. The better you understand coding, the better you can direct AI. When I needed to implement code completion in Launchpad or structure how lesson content would get served to the add-in lessons, my understanding of how code editors and databases work helped me ask AI for exactly what I needed. It's like how a master builder's knowledge of stone cutting meant they could give better directions to the stonecutters.
Now, I should acknowledge something important: building a Gothic cathedral is vastly more complex than creating a Revit add-in. A cathedral represents centuries of accumulated knowledge, countless craftspeople, and literally tons of material that had to be perfectly balanced. My comparison isn't about complexity - it's about the role of understanding the process and directing the work. The principles of needing to understand your craft to effectively guide its creation remain the same, even if the scale, complexity, and context are different.
I have to say, through this process, I gained a deeper appreciation for both programming fundamentals and higher-level software design skills. That's why Launchpad focuses on teaching those crucial programming basics - the syntax, patterns, and concepts you need to work with the Revit API. Think of it like learning the properties of different building materials and basic construction techniques. You need this foundation before you can think about designing entire systems.
Just as construction evolved from individual craftspeople to master builders to our modern teams of architects, engineers, and contractors, programming is evolving too. We still need those fundamental skills - understanding variables, loops, functions, and how code works. But we also need to develop higher-level abilities to work effectively with AI and modern development tools.
I've seen this in my own journey. When I first learned to code, it was all about memorizing syntax and debugging line by line. Now, working with AI, I still use that knowledge, but differently. Instead of writing every line of code, I'm evaluating the AI-generated code, spotting potential issues, and thinking about how different parts of the system work together. The fundamentals haven't become less important - they've become the foundation for these new skills.
So let's return to our original question: "Why learn to code in the age of AI?" The answer lies in the lessons of those medieval master builders. They didn't just know how to cut stone or lay bricks - they understood how all the pieces fit together to create something extraordinary. Today's programmers need that same comprehensive understanding. The fundamentals of coding aren't becoming obsolete - they're becoming the foundation that lets you orchestrate AI's capabilities effectively. Just as master builders used their deep knowledge to push architectural boundaries, we can use our programming expertise to push the boundaries of what's possible.
This isn't just about writing code anymore - it's about having the knowledge to envision complete solutions, the expertise to evaluate AI's output, and the understanding to know how different parts of a system should work together. As I learned while building Launchpad, AI isn't replacing the need for programming knowledge - it's amplifying its value. It's elevating coders into digital master builders who can create more ambitious, more innovative solutions than ever before.
Thank you for listening to this episode of the ArchSmarter podcast. If you found this helpful, please hit that subscribe button and leave a review. Remember - in the age of AI, understanding fundamentals isn't becoming less important, it's becoming absolutely essential. Until next time, I'm Michael Kilkelly. Keep working smarter, not harder!