The Secret Language of Business: Unlocking Truth with Airtable and the CMCC

Imagine this: You’re booking a rental car. Simple, right?

You choose a car type. Economy, SUV, or something flashy. You add insurance. Or maybe not. You pick the dates. Maybe you return it at a different location. Maybe you’re under 25, and now there’s a surcharge. All of this happens in a few clicks. But behind the scenes, a labyrinth of business logic governs every step.

What if you could capture all of that logic — every rule, every constraint, every calculation — in a way that both humans and machines could understand, without writing a single line of imperative code?

That’s the premise behind a radical but beautifully simple idea: use Airtable as a declarative modeling environment that fulfills the Conceptual Model Completeness Conjecture (CMCC).

The Rental Car Truth Model

Let’s stay with our car rental example. In Airtable, you create tables:

• Cars (Make, Model, Type)
• Customers (Name, License, Age)
• Rentals (Car → linked record, Customer → linked record, Start Date, End Date, Add Insurance? → checkbox)
• Pricing Rules (Conditions, Rate per Day, Surcharges)

Each of these tables, fields, and relationships — when paired with Airtable’s built-in formula fields and linked references — map cleanly onto the CMCC primitives:

• Schema (S) — The tables, fields, and types
• Data (D) — The records and values
• Lookups (L) — Linked records and selects
• Aggregations (A) — Rollups, counts, summaries
• Lambda Calculated Fields (F) — Airtable formulas (“if age < 25, add surcharge”)

Now here’s the magic:

Airtable’s /api/meta gives you a machine-readable description of the schema. Airtable’s /api/data gives you the live domain facts.

Together, they form a complete semantic model of the business, cradle to grave.

Truth Flows Downstream

This model becomes your single source of truth — not just for documentation, but for everything else:

• OpenAPI specifications can be derived from the schema.
• Frontend and backend code scaffolds can be generated based on meta and data.
• Validation logic and pricing rules can be inferred directly from formulas.
• Test cases and edge conditions come from the data itself.

It’s like Git, but for business rules.

Even if Airtable isn’t your final runtime, it doesn’t matter. The model is true, and that truth is portable. Tools like ssotme:// let you export your Airtable model into Baserow, generate SDKs, or even seed production environments in other stacks.

Emergent Truth, Not Constraints

You might be tempted to think of this as a constraint system. But it’s more radical than that.

Traditional approaches — like Model-Driven Engineering (MDE), UML, OCL, or Prolog — tend to start with a language and define what can’t happen. They operate like bureaucracies: full of red tape, rules, and procedures to avoid error.

The CMCC model doesn’t work that way.

It doesn’t start with syntax. It doesn’t even start with structure. It starts with facts — little fragments of truth.

Let’s put this in context. Think about three very different situations:

• In geometry, you don’t need to ‘prove’ the Pythagorean theorem if you already know the side lengths and that one angle is 90°. Once the facts are declared, the theorem simply emerges.
• In baseball, you don’t need to write a function to say “the inning is over.” Just record three outs, and the aggregator logic will recognize what that means.
• In quantum physics, once a measurement is declared, you don’t need a procedure to ‘collapse’ the wavefunction. The amplitudes and constraints do that on their own.

A car was rented from May 2 to May 5.
The customer is 24 years old.
They added insurance.
The car type was SUV.

Each of these is a micro-truth. But once you stack them together, structure begins to surface. Add enough, and patterns and implications begin to materialize — surcharges, eligibility rules, price calculations — all without a single IF statement. You didn’t code the logic. You just enumerated what’s true.

That’s not a constraint system. That’s emergent logic. That’s emergent logic.

In a CMCC-complete model, once the facts are in place, the truth becomes unavoidable. Like geometry birthing the Pythagorean theorem, or baseball summing to three outs, or quantum mechanics collapsing a wavefunction — you never wrote the rules. You just wrote the world.

Who Needs to Know This?

• Business Analysts get a tool to model requirements with precision and no ambiguity.
• Developers get semantically complete specifications that generate real code.
• Executives get visibility into how the business actually works, in real-time.

What Comes Next?

We’re just getting started. Next, we’ll walk through building such a model step by step — starting with the Cars, then the Rentals, then layering in Pricing and Rules. You’ll see how simple it is to describe something complex, when you’re speaking the right language.

Spoiler: it’s Airtable. And it’s not just a spreadsheet. It’s a canvas for modeling truth.

Stay tuned.

References & Further Reading

• Completeness: Codd to Turing, to Gödel, to… Me?
  This is where I first laid out the CMCC — the idea that just five declarative primitives (Schema, Data, Lookups, Aggregations, Formulas) are enough to express any finite business rule. It’s both a tribute and a challenge to the giants whose shoulders we stand on.
• Datomic — Time-Traveling Data, Immutable Semantics
  A deep dive into how Datomic nails seven out of ten CMCC criteria — including time travel and immutable facts — and what’s still missing for a perfect score. If you’re looking for a real-world system that comes close to the ideal, start here.
• MDE Monday #2: Live or Locked? Unifying Design-Time and Run-Time in One Model
  One of the biggest frictions in semantic negotiation is the gap between what we design and what actually runs. This piece shows how CMCC collapses that gap — live rules, live snapshots, zero drift.
• Prove Me Wrong: Every Idea in the Universe Melts into These 5 Primitives
  I asked skeptical LLMs to break the five-primitives conjecture with the most bonkers rules they could invent. They failed. If you’re wondering how far this idea stretches, this is where we pressure-test its limits.
• The Five-Piece Rulebook
  A skeptical friend tried to poke holes in CMCC, but ended up modeling the absurd with it. This conversational piece breaks it down in lay terms — perfect for sharing with folks outside the data-nerd echo chamber.

Join the ssotme:// Protocol

The rulebook is not the code. It’s the source of truth.
Versioned. Declarative. Collaborative. Like Git — but for business logic.

• Install the CLI: npm install ssotme/cli
• Website: EffortlessAPI.com
• Contact: start@anabstractlevel.com

#CMCC #BusinessRules #SingleSourceOfTruth #DeclarativeModeling #Airtable #RulebookNotCode #NoCodeClarity #SemanticIntegrity #StructureOverSyntax