How can Building Code Compliance be “Antifragile”

Fair warning: this post is part rant, part thinking out loud, and part trying to make sense of how messy systems I spend way too much time thinking about can work.

Let’s be honest.

Building code compliance is not sexy.

It’s paperwork. Inspections. Missing forms. Someone forgot to put the CF1R on the drawings again. And somehow… this is how we’re supposed to protect public safety and energy goals.

So let’s talk about a simple idea called antifragile — and why it actually fits building code implementation really well.

And yes, this post is inspired by the book Antifragile by Nassim Nicholas Taleb on my Libby’s library shelf. The book introduces the idea that some systems don’t just survive stress and problems — they actually get better because of them. And if you’ve worked in construction before as a designer, contractor, or even as a homeowner or renter, you know that there’s plenty of problems and stress with construction to share all around.

The book isn’t about building codes or energy compliance, but it got me thinking about how this idea could apply to real-world energy codes, construction, and the way implementation systems can actually function.

First: What Does “Antifragile” Even Mean?

Most things fall into three buckets:

• Fragile — breaks when stressed
  (Glass. Eggs. Overly complicated compliance systems.)
• Robust — survives stress but stays the same
  (A rock. A binder full of rules.)
• Antifragile — gets better because of stress
  (Muscles. Immune systems. Good feedback loops.)

Most code systems try to be robust.

Antifragile systems say, “Stuff will go wrong. Let’s learn from it.”

The Problem: We Treat Problems Like Embarrassments

In building code compliance, we often act like:

• Noncompliance = failure
• Data gaps = mistakes
• Different enforcement styles = inconsistency to eliminate

So we try to:

• Average things out
• Hide the messy parts
• Pretend the system is cleaner than it really is

That’s fragile thinking.

Antifragile Thinking Flipped The Switch

Instead of asking: “Why isn’t everyone complying the same way?”

Ask: “What is this mess trying to teach us?”

What This Looks Like in Real Life

An antifragile building code system:

• Expects mistakes
• Tracks patterns, not just averages
• Uses failures to guide training and policy
• Focuses effort where things are hardest
• Gets better every few years

Not perfect. Not clean. But stronger over time. This sounds kind of fitting to building code implementation systems.

How Antifragile Thinking Fits Energy Code Compliance in California

California’s energy code system is big, complicated, and always changing.

We have:

• New code cycles every 3ish years
• Different rules for different buildings under different scopes
• Over 500 local jurisdictions (I only learned about this growing number at the CEC)
• Many people involved (Owner, leaser, lawyers, realtors, inspectors, plan checkers, designers, contractors, different trades, and energy consultants, etc.)
• And a lot of paperwork moving between all of them

Because of all these wonderful and natural combination, things will go wrong. That’s not a surprise. That’s normal.

Under Antifragile thinking, the simple idea is: Instead of trying to stop every problem, use problems to make the system better.

So I’ve been racking my brain on how this concept can apply to specific examples — selfishly — things that are applicable to what I’m privileged to work on every day currently. This is what I came up with.

Example 1: Using Noncompliance as a Signal, Not Just a Mistake

When a project doesn’t comply with the energy code, the usual response is simple: point out the mistake, fix it, and move on. The decision on how to “fix it” is mostly left to the local building department.

So what do building officials and inspectors naturally do over time?
If they keep seeing the same mistake show up again and again, they realize it’s probably not random. Once that pattern is clear, they start watching for those same issues in similar projects in the future.

Now imagine this.

Every correction — every correction slip — is recorded digitally, not just people’s brain and experience. Not as scanned handwritten notes or word docs with their own decorations, but as clean data in a table. Let’s go one step further and imagine that all corrections are captured digitally, even the ones inspectors talk through with contractors but don’t formally issue as correction slips.

At that point, you can clearly see:

• Which mistakes show up over and over
• Which ones are rare or unusual
• Where problems cluster by measure, building type, or project scope

If you have, say, 70 or more best samples within the same scope, you can start to reach a reasonable level of confidence about what actually needs closer attention.

So what can you do with that information?

A lot.

• At the state level, this feedback loop can highlight energy code requirements that are unclear or frequently misunderstood.
• For program implementers, repeated documentation issues can signal where training isn’t reaching the right people.
• For vendors and software developers, patterns may show where tools don’t match what actually happens in the field.
• For local jurisdictions, sharing this information openly with contractors can raise the bar, improve consistency, and make it easier for the workforce to succeed.
• For contractors, if they know the inspectors are going to look for something, they’ll try to get it right the first time.

This approach turns noncompliance into useful information — about what’s happening, where it’s happening, and why.

Get Yung Codes’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

And honestly, this isn’t some futuristic idea.

My doctor already records our conversations using AI tools, and that information likely ends up as rows in a database that helps improve care over time.

So the real question is: Why can’t building department staff— the doctors of our built environment — get the same support?

Example 2: Different Cities Enforce the Code Differently — and That’s OK

In California, energy code enforcement looks different everywhere. It took me some time to learn this and really experience it.

Some jurisdictions:

• Have dedicated energy specialists
• Have strong plan review but limited inspections
• Are short-staffed and stretched thin

This difference is often treated as a problem to erase.

A fragile response is to force uniformity and tries to make every city enforce the code in the exact same way. The problem will never go away because real life doesn’t work that way. There are inherent inefficiencies in government (e.g. hiring, guardrails, blah blah bleh) that will not make that solution successful. When you force uniform rules onto very different local jurisdictions one or two things happen:

• The rules get watered down so every can “meet” them, or
• Cities quietly work around them to survive

Either way, you lose information about what actually works.

Antifragile thinking says:

• These differences between cities are real-world testing. Some cities enforce strictly and catch issues early. Some rely more on documentation. Some focus on inspections an riskiest measures.
• Then we can ask: Which approach hold up when staff is limited? Which practices catches the most problems with the least effort? Where does it breakdown?

Each city becomes a real-world experiment — without anyone having to design one on purpose.

Instead of forcing everyone into the same mold, the system can:

• Learn from what works in practice
• Share effective approaches
• Focus support where it’s needed most

Variation becomes a learning tool, not a weakness. Antifragile thinking doesn’t pretend cities are the same. It uses their differences to make the system smarter.

Now, I know what you’re thinking. If different cities enforce the code differently, doesn’t that send the message that the rules don’t really matter — or that people can ignore them if they think the rules don’t apply to them?

Short answer: No.

Antifragile thinking does not mean different rules for different cities.
It means different paths to the same rules. What changes is how enforcement works under real-world conditions.

What stays the same:

• The requirements don’t change by city
• The performance targets don’t change
• Noncompliance is still noncompliance

What changes is how enforcement works under real-world conditions.

Some cities may:

• Focus inspections on the riskiest measures to the region
• Rely more on documentation where staffing is limited
• Catch issues at different points in the process

It can feel unfair if enforcement doesn’t look the same everywhere. Antifragile thinking asks questions like if the same types of buildings are meeting the same standards over time, what are the highest risk issues being caught and corrected, and is compliance improving not just paperwork. Fairness comes from consistent expectations and accountability. We can’t pretend every city has the same resources. The pro of having a single central authority can speed up larger scale development. The pro of having decentralized authorities provide flexibility and support local workforce.

Example 3: Paperwork Problems Show Where the System Is Fragile

Energy code compliance in California relies heavily on forms, files, and handoffs.

When things go wrong, it’s often because:

• A form is confusing
• A step is easy to miss
• Responsibility isn’t clear
• Too many people touch the same document or nobody touch the document they’re supposed to

If lots of projects mess up the same step, that’s a sign the system is fragile there.

An antifragile approach asks: Can we simplify this? Can we remove steps? Can we make errors harder to make? Can we design an information system that self-identify mistakes?

It’s fixing the process, not blaming the people.

4. New Code Cycles Are Stress Tests (and That’s a Good Thing)

Every new energy code cycle puts stress on the system:

• New requirements
• New technologies
• New learning curves

Each cycle becomes a chance to:

• See what requirements are hardest to implement
• Identify where training falls short
• Improve enforcement tools and guidance

I’m still learning about the code process and to think in what way this stress test can be applied to make the next cycle better, but maybe I’ll defer it to the experts.

Final Thoughts

At the end of the day, antifragile thinking is really about one thing:
using stress to make the system better instead of pretending stress shouldn’t exist.

Energy code compliance will never be perfect. There will always be mistakes, gaps, and messy handoffs between people and systems. That’s not a failure — that’s the reality of how construction and enforcement work in the real world.

It keeps the rules firm, but treats problems as signals instead of embarrassments. Over time, that leads to clearer requirements, better training, smarter enforcement, and a system that actually improves with each code cycle versus starting over with a new implementation strategy every few years as people find problems (which will never cease to exist).

On a more personal note, this way of thinking also hits close to home for me. It lines up a little too well with my high-functioning anxiety — always scanning for problems, always trying to stay ahead. Antifragile at least gives that instinct a better name than “just a coping mechanism,” and maybe even points it in a healthier direction.

So I’ll end with a question:

What would energy code compliance look like if we designed it to learn on purpose?

And can you think of other places — inside or outside building codes — where antifragile thinking could help systems get stronger instead of just more rigid?