01-05: Scrappy Scripting
===
Hey, it's Michael from ArchSmarter. In this episode, we're talking about something that's near and dear to my heart, and that's the power of scrappy scripting. You know what's better than a perfect script or a perfect tool? That's a script that actually gets finished and does the job. Now, I see this a lot.
People get stuck in the planning phase of their tools. They're trying to create the perfect solution, the perfect automation, the perfect tool, and they're trying to account for every edge case, every possible scenario. And you know what happens? Nothing. The tool never gets built because perfect becomes the enemy of good enough.
Let's talk about what we mean by Scrappy. When I think of Scrappy, I think of those MacGyver style solutions. You know, the creative fixes you come up with when you're under pressure. Now, the Cambridge Dictionary defines Scrappy as having a strong, determined character. Something that's, or somebody that's willing to argue or fight for what you want.
And that's exactly the [00:01:00] spirit of Scrappy Scripting. It's not about having the most polished solution. It's about being resourceful, adaptable, and laser focused on getting results. Think about it like this. Professional software development is like building a four lane suspension bridge. It requires extensive planning, a big team, and consideration of countless variables.
Weather, soil conditions, seismic, all that stuff. Scrappy Script But scrappy scripting, it's more like building a quick footbridge over a stream. It's targeted, specific, and it solves an immediate problem. Now both have their place, but you don't need a suspension bridge to cross a creek. Let me give you some real world examples of what scrappy scripting looks like in practice.
I had a student in my Revit add in bootcamp who works for an exterior wall panel manufacturer. As part of the shop drawing creation process, he had to manually create all the sheets [00:02:00] for every panel in the project. Now every sheet had multiple views and the project had hundreds of panels. So we're talking about a lot of manual work.
Now instead of waiting for somebody else to develop a comprehensive solution, he wrote a simple Revit add in. It wasn't fancy, just a basic form with a few buttons. And to start, it didn't have any fancy error handling, there was no progress bar, you know, no beautiful interface. But you know what? It greatly reduced the time it took to produce those drawings and it really saved the project money and improved his quality of life.
Now this reminds me of my own journey with Scrappy Scripting. Back when I was working at Gary Partners, I was on a big mixed use project in Brooklyn, and I've talked about this here before in the podcast. Now after every deadline, I'd stay late cleaning up files, uploading them to the client's website.
Now my first automation attempt was pure Scrappy. It was ugly. It was basically held together with duct tape and a whole lot of hope. But that ugly script took an [00:03:00] eight hour process down to just one hour. music ends Now let's break down the key elements of scrappy scripting. First, start with a clear problem.
Not a general, wouldn't it be nice if, but a specific, I need to do this and it's taking too long. The more specific the better. Second, Focus on the happy path. That's when everything goes according to plan. Start there. Don't worry about all the things that could go wrong. At least not yet. And third, embrace imperfection.
Your first version might be rough around the edges and that's okay. You can always improve it later. Now, let me share another example. One of my Revit Adam Bootcamp students works for a mechanical engineering firm and they have the tedious task of checking equipment schedules against The office and project standards now the manual process was mind numbing.
So open up each schedule, check the parameters, and you're looking at things like flow rates, electrical [00:04:00] requirements, sizes, and they're doing this against a standard Excel spreadsheet. So you're comparing one to the other and they had to mark any differences. So this had to be done for hundreds of pieces of equipment on every project.
So his first add in, it was about as basic as you could get. Just a simple form with a button that would read their Excel standards file and highlight any scheduled values that didn't match up. There were no fancy graphics, no, no complex interface, just red text for anything that didn't match. Was it elegant?
Nope. Did it cut a three hour process down to about five minutes? Absolutely. And you know what? The last time I checked in, that same quick and dirty tool was still being used at their office two years later. This brings us to an important principle, and that's the 80 20 rule, which I talked about in the last episode of this podcast.
Now in automation, your first quick attempt is often going to handle 80 percent of the cases. The remaining [00:05:00] 20%, those are your edge cases. Well, that's where things get tricky, and that's where people often get stuck. Now, let's talk about some specific areas where scrappy scripting can be used to make an immediate impact.
Now, the first one is with data management. Now, maybe you're constantly copying data between Excel and Revit. Nobody wants to do that. It's not fun. But a simple script that reads an Excel file and updates parameters in Revit could save hours every week. And it's going to do it a lot more accurately than you sitting there copying and pasting fields.
And it doesn't need to handle every possible format, every condition, just the ones you actually use and the ones that are causing you the most pain. Now another area is in file management. And file organization. Think about project folder setup. Now, instead of creating the same folder structure manually every time, a real basic script could do it in seconds.
And sure, you could build a sophisticated app with beautiful interface, but a simple [00:06:00] script or a simple batch file that creates folders and copies template files does the job just fine. And third, drawing cleanup. So do you spend a lot of time cleaning up CAD files you get from consultants? A basic AutoLisp script or VB script that purges unused layers, scales the drawing correctly, and places it on the right coordinates, again, might not handle every edge case, but it could handle most of them and it could save you a whole lot of time.
Let me show you what I mean with a real example from another one of my Revit Ad and Bootcamp students. They were working on a large hospital project and they needed to create detailed partial plans for each department in the hospital. Now the manual process was tedious. Create a dependent view, find the right scope box, apply it to the view, and then rename the view based on the combination of the scope box and the department name.
And they were doing this dozens of times for each floor. So their first add in was super basic. Just one form with a drop down [00:07:00] to select the scope box and then a button to create the dependent view. Again, nothing fancy here. The add in would just grab the scope box name, create the dependent view, apply the scope box, and then name the view based on the rules that they had set.
And this was all within one click. Was it perfect? Could it handle every possible naming convention or view type? Definitely not. But it turned a five minute process into a five second one. And if you have to do this a hundred times like that, time starts to really add up. Now, the interesting part, a year later they told me that they'd created over 500 views with that same temporary solution.
Why? Because it worked. They never needed the fancy features that or they originally thought were essential. Now, I know what some of you might be thinking, but what about quality control? What about maintainability? What about best practices? These are all valid concerns, but here's the thing. Scrappy doesn't mean sloppy.
It means focusing on what matters most right [00:08:00] now. It's about being pragmatic rather than perfectionist. Think about it this way. Let's say you're sketching out some design concepts. You don't always start with perfectly straight lines and then detailed notes. No, you start with a rough sketch that captures the main ideas.
Scrappy scripting is like sketching with code. So how do you know when your automation is good enough? I recommend looking at these three signs. One, your ScrappyScript saves significant time compared to the manual process. Two, it handles your most common cases. Again, not everything, but the most common cases.
And three, most importantly, other people can use it without calling you every five minutes. Now let me share another ScrappyScripting. Start small, number one. Begin with a single task, and this is one that's causing you a lot of pain. Don't try to boil the ocean. Pick [00:09:00] something specific and solvable. Just boil that pot of water.
Number two, use what you know. If you're comfortable with Dynamo, start there. If you're really good at Excel macros, start there. You know a bit of Python, go ahead and use that. The best tool is the one that you'll actually use. Three, build in small increments. Get the basic functionality working first, then add those additional features as you need them.
We call this incremental development, and it's really just common sense. And then four, document just enough. You don't need formal documentation, but leave yourself some breadcrumbs. A few comments explaining what the script does and how to use it can save future you a lot of headaches. Alright, here's my last list, and that's my three step approach to getting started with scrappy scripting.
So start with the most common use case. Solve the 80 percent problem first, add just [00:10:00] enough error handling to prevent disasters, and then test it with real users. You don't need extensive QA, just get it in front of a few people. So here's your challenge for the week. Pick one tedious task that you do at least weekly.
Block out 30 minutes or so, just 30 minutes, and then open up Dynamo, Visual Studio, Excel, whatever, and start automating that task. Don't worry about making it pretty, don't worry about all the things that could go wrong, all the edge cases, just get something to work. Want some ideas to get started? Here are some common tasks that are perfect for scrappy automation.
Renaming views in Revit based on a naming convention setting up project folders and copying project templates. Creating a list of PDFs in a folder. So this is basic, but it's a really useful script. Pick one of those or come up with your own and start there.
Remember, you're not trying to build the next Revit, the next AutoCAD. You're just trying to make your [00:11:00] work a little bit easier. Alright, so remember, scrappy doesn't mean sloppy. It means practical, resourceful, and focused on results rather than perfection. Start small, start simple, but most importantly, just start.
If this resonated with you, hit that subscribe button right now. And hey, share this episode with a colleague who's always talking about automation, but never actually starting. Maybe this will be their push to get scrappy with it. This is Michael Kilkelly with ArcSmarter, reminding you that sometimes the best solution is the one that's actually finished.
Thanks for listening.
