A project architect friend in San Francisco said something about building codes that I can’t stop thinking about.
A close friend of mine is a project architect at a San Francisco architecture firm. She’s one of those people who makes chaos look normal. Consultant coordination, redlines, permit sets, client emails, internal reviews, and the kind of late nights that become routine in practice.
Working late isn’t something she dramatizes. It’s just what the job demands. But every once in a while she’ll send me a message that makes me laugh because it’s too familiar. A screenshot of a code section highlighted like a crime scene. A photo of her desk at midnight. Or a short line like:
“Code uncertainty is still the biggest mental tax.”
That message stuck with me. Not because architects don’t know how to research code. We do. We’ve been trained to. But code research isn’t just reading, and it isn’t even searching.
It’s reasoning. And it’s high-stakes reasoning.
So when she said this recently, it hit me like a truth we don’t say out loud enough:
“AI gives me answers. But it doesn’t give me the reasoning.
I don’t need confidence. I need defensibility.”
That one sentence made me realize something. If AI is going to truly transform architecture, the breakthrough won’t come only from prettier renderings or faster concept iterations. It will come from solving the most unglamorous, most expensive part of our workflow.
Building codes.
Code research is still broken (and everyone knows it)
Let’s describe building code research honestly.
Even today, it often looks like:
- digging through PDFs
- keyword searching documents that weren’t built for search
- bouncing between digital code libraries
- cross-checking referenced standards
- hunting for exceptions buried in dense language
- slacking a senior team member for a sanity check
- calling a code consultant because you can’t risk being wrong
- then repeating the same research again next project
We’ve normalized this because it’s how the profession has always worked. But it’s absurd when you step back.
AEC is one of the most regulated industries in the world. We design spaces where people live, work, heal, learn, and gather. Compliance isn’t optional. It’s foundational. Yet the tools for arriving at compliance decisions remain largely manual, and worse, non-reusable.
One team figures out a compliance interpretation and it disappears into meeting notes, email threads, or someone’s memory. The next project repeats the same cycle because nobody can find the precedent, or nobody trusts it.
That’s not a workflow. It’s a tax.
The market is growing, and that’s a good thing
One thing I’ve learned from following this space is that the AEC industry is finally experiencing real momentum in software innovation. And honestly, it’s overdue.
We’re seeing a healthy ecosystem form across different needs.
Online code libraries and search tools have made a huge difference for practice. UpCodes, for example, is arguably best-in-class as an online code library. Fast navigation, clean UX, and strong search. For many architects, it has become the default way to look up code language compared to digging through PDFs.
But even the best code libraries are primarily optimized for finding code, not necessarily reasoning through it. In other words, UpCodes is excellent at search and discovery. But AI-driven code research is a different challenge entirely.
At the same time, there’s a growing wave of tools focused on plan review workflows. Products that help with QA, flagging issues, review coordination, and streamlining permitting processes. This is exciting, especially because it addresses real bottlenecks and reduces back-and-forth.
And of course, there’s another rapidly expanding domain that architects are paying close attention to. 3D BIM model-based tools. Since many firms now design in 3D from early stages through CDs, software that can interpret BIM models, automate checks, or improve coordination is incredibly compelling.
So yes, the market is expanding in multiple directions, and that’s a good sign. It means AEC is growing, and innovation is accelerating.
But despite all this progress, there’s still one gap that keeps showing up.
When AI arrived, architects had the same hope
Like most architects I know, my friend tried AI early.
At first it felt like magic. The idea that you could ask:
- “Do we need a rated corridor here?”
- “What triggers sprinklers in this condition?”
- “What’s the exit width requirement for this occupancy?”
And get an answer in seconds.
That felt like the productivity leap we’d been waiting for. And to be fair, AI was helpful sometimes. It was faster than flipping through code books and faster than manually hunting across PDFs.
But reality showed up quickly.
Real code questions aren’t simple. They’re conditional. They depend on:
- occupancy classification
- construction type
- building height and stories
- fire area thresholds
- sprinkler status
- egress path conditions
- local amendments
- adoption cycles
- referenced standards
- exception chains that override exception chains
So the questions become:
- “If this is R-2 over podium, does this exception still apply?”
- “Does the local amendment change the trigger condition?”
- “Are we sure this interpretation holds up in plan review?”
This is where many AI tools start to feel unreliable. They can retrieve relevant sections. They can summarize. They can sound convincing. But they often struggle with multi-step reasoning and jurisdiction nuance. More importantly, they rarely show their work.
That’s the gap between an AI that’s interesting and an AI that’s usable.
Architecture doesn’t run on answers. It runs on decisions you can defend.
The first tool that made me think, “Oh. This is real.”
A few weeks ago, I came across a platform called Melt Code by MeltPlan.
At first, I assumed it was another entrant in a crowded category. But one thing stood out immediately. They weren’t just saying “we answer code questions.”
They were emphasizing something different.
AI that researches the code and explains the research.
That caught my attention because it directly addressed what my friend had been saying for years:
“How do I trust AI when I know it can make mistakes, if it doesn’t show me the process?”
So she tried it.
And for the first time in a long time, I heard her say something I didn’t expect:
“This actually helps.”
Not “it’s cool.”
Not “it’s promising.”
Helps.
Why Melt Code felt different to a practicing architect
No tool eliminates the need for professional judgment. Building code compliance is complex and always will be.
But what impressed my friend is that Melt Code doesn’t behave like a black box. It behaves like a structured code researcher.
It doesn’t just give you a requirement. It shows you how it arrived at the requirement.
That’s the difference between “AI said so” and “here’s the reasoning chain with the cited sections and triggers.”
And in real practice, that difference matters more than speed.
Because when you’re in a meeting and someone asks:
“Are we sure this is compliant?”
The answer cannot be:
“The AI told me.”
It needs to be:
“Here’s the logic, here’s the code trail, here’s why exceptions apply or don’t.”
That’s defensibility. That’s trust.
Code knowledge should compound, not disappear
The other thing Melt Code seems to understand is that compliance work isn’t just individual research. It’s organizational knowledge.
Firms don’t just need answers. They need repeatable decisions, reusable checklists, project memory, structured compliance workflows, and a way to retain expertise over time.
Because the real pain isn’t the first time you research a requirement.
It’s the 30th time.
Melt Code includes features that help teams organize code research properly and retain code decisions over time, so knowledge compounds instead of disappearing.
The real result is fewer hours, fewer consultations, better weeks
My friend told me two things started shifting almost immediately.
First, it saved hours. Real hours. Time that used to disappear into code rabbit holes was compressed into structured reasoning and verification.
Second, it reduced the number of times she needed to escalate to a code consultant. Not because consultants aren’t valuable, but because more questions could be resolved confidently before escalation.
Then she said something that captured the value better than any feature list ever could:
“I have a few more hours every week now.
And I’m not spending them on code.
I’m spending them on design.”
If you’re an architect reading this, you know exactly what that means.
That’s not just productivity. That’s quality of life.
The real disruption isn’t AI. It’s explainable AI.
After watching my friend use Melt Code and researching what MeltPlan has built, I think I understand what makes this different.
The disruption isn’t that it uses AI.
It’s that it’s not an uncertain black box.
It shows what it did. It makes the reasoning visible. It lets professionals cross-check the chain instead of blindly trusting the output.
And in AEC, that changes the game completely.
Because the industry doesn’t need another tool that generates answers.
It needs tools that generate defensible conclusions.
And for the first time, it feels like AEC has a tool that truly understands that.
Read More From Techbullion
