Code & Compliance Checking

Start with the real value, because it is substantial. Codes and standards are long, dense, cross-referenced and written in language that takes practice to parse. An LLM is a strong reading aid here. Paste a clause and ask what it actually requires in plain words. Ask which parts of a code are likely relevant to a small clinic, a mezzanine, or a change of use - to build your reading list, not to replace the reading. Ask it to explain the intent behind a fire-egress or accessibility requirement so you understand what you are designing toward.

It is also useful for internal consistency checks - a different thing from compliance. Does my door schedule match my floor plan? Does the spec call for a fire rating the drawings do not show? Have I described this stair two different ways? These are questions about your own documents agreeing with each other, and the model can surface conflicts you would otherwise miss. Consistency is not compliance, but inconsistency is a common route to non-compliance, so catching it early is worth a lot.

And it drafts excellent checklists. Ask for a structured accessibility or fire-safety checklist for your project type and you get a thorough scaffold to work through - which you then confirm against the actual, current code. The theme in all of these: the model helps you read, organise and not forget. It is doing preparation and triage, not adjudication - the same supportive role it plays everywhere in this module, just with the highest stakes attached.

Now the hard limits, because they are the reason this lesson exists. First, LLMs misremember specifics. Code numbers, clause references, exact dimensions and clearances are precisely the kind of detail a language model gets confidently wrong - it predicts a plausible-looking number, not the real one. A cited IS or code clause may be misnumbered, superseded, or invented outright.

Second, codes are local, layered and change. What applies depends on jurisdiction, occupancy, date and local amendments - national code, state or municipal by-laws, fire-service requirements, and revisions that land regularly. A model's training has a cutoff and no reliable sense of your specific local overlay. In India, for example, the National Building Code and many IS standards are periodically revised (NBC 2016 has been superseded by SP 7:2026), and a model may cite the old version as current.

Third, and most dangerous, a compliance verdict is a false comfort. When a model says this complies, it is producing agreeable text, not performing a legal check - and because it sounds authoritative, it invites you to stop looking. That is the opposite of what compliance work needs. Treat any it complies from an AI as noise; the only compliance statements that count are ones a qualified person will put their name to and the authority will approve. The model can help you get there faster; it cannot get you there.

Put the two halves together into a disciplined loop. Feed the AI your drawings and spec and ask it to flag things to check - possible conflicts, likely-relevant code areas, apparent omissions - explicitly as a shortlist to verify, not a verdict. Then you read the actual, current clause for each flagged item, confirm it against source, and correct the design. Finally, the compliance statement is made and signed by a qualified professional, and formal approval comes from the authority having jurisdiction. AI sits only in the first step.

Some prompt discipline keeps you on the safe side. Never ask does this comply? Ask instead for the questions you should be answering:

Weak (dangerous):  "Does this bathroom layout comply with
                    accessibility requirements?"
Better (safe):     "List the accessibility questions I should check
                    for this bathroom layout - clear floor space,
                    door width, grab-bar zones, turning circle.
                    For each, tell me what to measure. Do NOT tell me
                    whether it passes - I will check the current code."

The better prompt uses the model for what it is good at - recalling the shape of what matters and turning it into a checklist - while reserving the pass/fail for you and the code. If you want the model to help with the code text itself, ground it: paste the actual current clause and ask it to explain or apply that text, rather than trusting its memory. Even then, you confirm; grounding reduces error, it does not remove your responsibility.

It helps to picture the loop as strictly one-directional. Information flows AI -> you -> authority, and authority never flows back to the AI as a shortcut. The model can hand you a shortlist and a plain-language reading; you turn that into verified findings against the current code; and the qualified professional and the authority turn those into an approval. At no point does the model's output skip a step and become the decision. Keep that arrow pointing one way and you get all of AI's speed with none of its false authority - the model widens what you can cover, and you and the code close every gap it opens.

It is worth separating a general chatbot from purpose-built automated compliance / code-checking software. Rule-based model-checking tools (in the BIM world, checkers that run defined rules against a model) and emerging AI-assisted compliance products are more structured than a chatbot: they encode specific rules, work against your actual model data, and are built and validated for the task. They are more trustworthy than free-text chat for the checks they cover - but they are still tools, scoped to the rules someone programmed, dependent on correct model data, and never a substitute for professional judgement or statutory approval.

The honest 2026 picture: fully automated, trustworthy compliance checking across the messy reality of real codes and real projects does not exist. Rule-checkers handle well-defined, geometric rules; AI assistants help with reading and triage; neither closes the loop. Regulatory approval remains a human, statutory process for good reason - the accountability has to rest with a licensed professional and an authority, not a model.

So whichever tool you use, the mental model is the same as the whole course: AI and automation are the assistant that widens your reach and catches what you might miss; you are the professional who verifies against the current code and carries the responsibility; and the authority signs off. Compliance is the sharpest example in the entire course of scrutiny scaling with stakes - here it scales all the way to do not trust the machine's verdict at all, and use it only to work faster and miss less.

Because compliance carries legal weight, there is one more discipline worth building around any AI use here: leave a clear trail of what you verified, separate from anything the AI produced. If you use a model to generate a checklist, treat that checklist as a starting scaffold, then record - clause by clause - the actual current code reference you read and confirmed, the value you measured, and your conclusion. What ends up in your project record should be your verified findings against real sources, not a chat transcript. The AI helped you get organised; the evidence of compliance is your own work against the code.

This matters for a simple reason: if a compliance question is ever raised, I asked a chatbot and it said it was fine is not a defence, and it is not something your professional indemnity insurer will thank you for. I checked clause X of the current code, measured Y, and confirmed it against the authority's requirements is. The model can never carry that accountability, so make sure your documentation reflects the human checking that actually happened.

There is a cultural point here too. As AI compliance tools improve, the temptation to lean on them will grow, and studios need a shared, explicit norm: AI is allowed to help you read, triage and not forget, but the sign-off is always a named professional's and the approval always the authority's. Set that expectation early - with juniors especially, who may not yet feel how confidently wrong these tools can be - and you get the speed of AI without ever quietly outsourcing responsibility that cannot, legally or ethically, be outsourced.