It is Thursday at 4pm, the permit set goes to the city's e-plan-check portal tomorrow morning, and the architect knows from experience that the plan checker for this jurisdiction will reject the package within ninety minutes of intake if the egress diagram does not match the floor-plan area calculations on sheet A-001, because that checker has done exactly that three times this year. Each rejection costs a full review cycle, often two to four weeks in the queue, on a project where the schedule has no weeks to give. AI can run a pre-submittal QA pass that catches a large class of these rejections before the set leaves the office: it cross-checks the egress against the area calcs, the accessibility clearances against the plans, the envelope and energy numbers against the code-prescribed values, and surfaces the internal inconsistencies that get a package bounced at intake. That is real value, squarely the consistency-checking AI is good at. But the moment the work shifts from checking whether the documents agree to interpreting whether the design complies with the code, it crosses a line the program has drawn since Level 1: code interpretation is the licensed professional's stamped act, never the AI's, and an AI that will confidently cite a section of the IBC that does not exist cannot be trusted to say what the code requires. This lesson is about using AI to win the AHJ round-trip on the consistency pass while the architect of record owns every code interpretation the submittal stands on, because the plan checker is unforgiving of both the inconsistency the AI can catch and the misinterpretation the AI will cause.

What Plan Check Is and Why the Round-Trip Is So Expensive

Plan check is the authority having jurisdiction's review of a permit set against the adopted codes, a gate the project cannot pass without: the AHJ reviews the documents, issues comments, and the design team responds, in a round-trip that repeats until the set is approved and the permit issues. The expense is in the round-trips. A package rejected at intake or returned with comments goes back into the review queue, and in a busy jurisdiction that queue is measured in weeks, so each avoidable rejection is not a few hours of rework but a multi-week schedule hit that can push a project past a financing milestone or a seasonal construction window. The architect's goal is to minimize the round-trips, ideally a first submittal approved or returned with only minor comments, because every cycle is expensive in the currency the project has least of, time.

Rejections come in two broad kinds, and the distinction is the whole key to where AI helps. The first is the internal inconsistency: the egress diagram that does not match the area calcs, the accessible route that does not match the clearances in the detail, the door schedule that disagrees with the life-safety plan, the energy form that cites different envelope values than the wall sections. These are coherence failures, the documents disagreeing with one another, and a plan checker catches them fast because they are mechanical to spot and signal a set that was not coordinated. The second is the substantive code issue: the egress capacity that is truly insufficient for the occupant load, the accessible route that truly violates a clearance, the assembly that truly fails the energy code. These are compliance failures, the design not meeting the code's requirement, and judging them requires interpreting the code against the design.

AI is strong on the first kind and dangerous on the second, which is the line this lesson draws. The internal inconsistencies are exactly the consistency-checking AI does well, holding the egress, area calcs, accessibility, and energy numbers across the set and flagging where they disagree, faster than a human coordinating the sheets by hand. The substantive code issues require saying what the code requires and whether the design meets it, which is code interpretation, the licensed professional's stamped act, and the place where the AI's confident fabrication makes it actively dangerous, as the next sections develop.

The Consistency Pass: What the AI Catches Well

The pre-submittal QA pass is the AI doing what it is good at, mapped to a class of rejection that is both common and avoidable. The AI reads the permit set and cross-checks the documents against each other: it compares the occupant loads and egress widths on the life-safety plan against the area calculations on A-001, checks that the accessible routes and clearances on the plans are consistent with the enlarged plans and details, confirms the envelope assemblies in the wall sections carry the same U-factors and R-values the energy compliance documentation claims, and verifies that the door and hardware schedule agrees with the egress and accessibility requirements the plans depict. Each is a coherence check, asking whether the documents tell one consistent story, and the AI runs them across a 200-sheet set far faster than a person flipping between sheets.

This is real analytic leverage because the inconsistencies are exactly what a strict plan checker bounces a set for at intake, and they are tedious to catch by hand because they live in the gaps between sheets that different people drew at different times. The egress diagram and the area calcs were prepared by different members of the team, the energy model and the wall sections by different consultants, and the inconsistencies creep in at the seams, where no single person is looking. The AI looks at all the seams at once, surfacing the mismatch between the area on A-001 and the occupant load the egress assumed, or the clearance on the plan that the detail contradicts, so the team reconciles them before the checker ever sees the set, catching the avoidable rejection in the office on Thursday rather than in the queue three weeks later.

The output is a pre-submittal QA report: a list of the internal inconsistencies the AI found, located by sheet, that the team reconciles before submittal. This is the same value the program named in the drawing-comparison and clash-detection lessons, the AI holding a large document set and surfacing where it disagrees with itself, applied to the inconsistencies that get a permit set rejected. The team still resolves each flagged inconsistency, deciding which sheet is right and correcting the other, because reconciling a mismatch is a design decision, but the AI's surfacing of the mismatches is the leverage, turning tedious, error-prone manual coordination into a fast comprehensive pass that catches the coherence failures before they cost a cycle.

The Hard Line: AI Fabricates Code Citations, So It Never Interprets the Code

Here is the line the lesson will not let blur. Catching an inconsistency is checking whether the documents agree; interpreting the code is saying what the code requires and whether the design meets it, and the second is the architect of record's stamped act, never the AI's. The reason is the failure mode the program has named since Level 1, especially acute in code work: a generative AI asked about the code will produce confident, fluent, specific citations that are fabricated. It will cite "IBC 1029.6.4" four times in a code narrative when that section does not exist, conflate the egress provisions of one occupancy with another, or state a clearance requirement from a code edition the jurisdiction did not adopt, all in the authoritative tone that makes the fabrication dangerous, because it reads exactly like a correct citation.

This makes the AI not merely unreliable but actively hazardous for code interpretation, because a fabricated citation that the team trusts goes into the submittal as the basis for a compliance claim, and the plan checker, who knows the real code, sees a citation to a section that does not exist or does not say what the narrative claims. That is worse than the inconsistency the QA pass was meant to prevent: it signals that the submittal's code analysis cannot be trusted, inviting deeper scrutiny of the whole package, and it can expose the architect, whose stamp certifies the code analysis, to a professional problem far larger than a rejected sheet. The AI's confident wrongness on code is the trap the program warned about, and code is where it bites hardest, because the code is specific, the checker is expert, and the stamp is on the line.

An AI will cite a section of the IBC that does not exist in the same confident voice it uses for a real one, so it can check whether your documents agree with each other but never tell you what the code requires, because the code interpretation is the architect of record's stamped act and a fabricated citation under a stamp is a problem far larger than a rejected sheet.

So the discipline is absolute: the AI may flag where the documents are internally inconsistent, and it may even draft prose for a code narrative, but every code citation and every compliance interpretation in the submittal is verified by the architect against the published, adopted code, because the architect's stamp certifies that the design complies and cannot rest on a citation the architect did not confirm. This is the tier-three code interpretation the program defined at Level 1, the licensed professional's authoritative act that AI may never own, and the permit set is where that principle meets its most exacting test, the expert plan checker reading every citation against the real code.

Two Jobs, Cleanly Separated: Coherence and Compliance

The workflow works only if the two jobs stay separate in the team's mind, because conflating them is how the AI's consistency value bleeds into a code-interpretation reliance it cannot bear. The first job is coherence: do the documents agree with one another, the egress with the area calcs, the plans with the details, the energy form with the wall sections. This is a checkable, internal question with a definite answer, the kind the AI answers well, and the team can largely trust the AI's flags here because a flagged inconsistency is verifiable on its face by looking at the two sheets that disagree.

The second job is compliance: does the design meet the code, the egress capacity sufficient for the occupant load, the accessible route meeting the real clearance, the envelope meeting the adopted energy code. This is an interpretive question against an external authority, the code, and it is the architect's to answer and stamp, because it requires knowing what the adopted code actually requires (not what the AI fluently claims) and judging the design against it. The team cannot trust the AI here, not because it is sometimes wrong, but because it is confidently wrong in a way indistinguishable from being right until the expert checker catches it, so the architect verifies every compliance interpretation against the published code regardless of how authoritative the AI's version sounds.

So the team reads the AI's output knowing which kind of claim each item is. A flag that A-001's area does not match the egress diagram is a coherence claim the team can act on directly. A statement that the egress complies with "IBC 1029.6.4" is a compliance claim the architect must verify against the real code, starting with whether that section even exists. The same AI produced both in the same confident voice, but they carry completely different trust, and the discipline is to sort them, because the consequences of the two failures, a missed inconsistency versus a stamped fabrication, are not remotely the same.

The Plan-Check Response Packet: AI Drafts, the Architect Owns the Interpretation

When the first round of plan-check comments arrives, the team responds to each one, and the response packet is the second place AI helps and the second place the line holds. The AI can accelerate the mechanical assembly: organizing the comments, drafting a response to each, locating the sheets and details that address the comment, and formatting the packet in the order and form the AHJ expects, real labor the AI compresses so the team turns the round-trip faster. A faster, well-organized packet shortens the cycle, the whole goal of minimizing the round-trip's cost.

But the substance of each response, the assertion that the design complies with the code the checker cited, is a code interpretation the architect owns and verifies. When the checker comments that the egress appears insufficient, the response that explains why it actually complies is a compliance claim under the architect's stamp, and it must rest on the real code, correctly cited and applied, not on an AI-drafted narrative the architect did not verify. The AI can draft the prose and assemble the supporting references, but the architect confirms that every citation is real and correctly applied and that the compliance argument is sound, because the response goes back to an expert checker who will read it against the code, and a response that cites a fabricated section or misapplies a real one does not just fail to resolve the comment, it deepens the checker's distrust of the whole submittal.

So the response packet follows the same division as the QA pass: the AI accelerates the assembly and drafting, the architect owns the code interpretation that is the substance of every response. The team gets the speed of an AI-organized packet, which turns the round-trip faster, without letting the AI's fluent code prose substitute for the architect's verified interpretation, because the packet is a code argument to an expert reviewer under the architect's stamp, and the stamp certifies the interpretation, not the formatting. The AI makes the packet fast; the architect makes the code in it true.

The Applied Problem: The Pre-Submittal QA Report and the Plan-Check Response

Here is the exercise, from the playbook. For a permit set going to a notoriously strict AHJ, produce two artifacts. First, the pre-submittal QA report: run the AI consistency pass across the set, cross-checking the egress against the area calcs on A-001, the accessibility clearances (ANSI A117.1 / ADA) against the plans and details, and the envelope and energy compliance (IECC 2024 / ASHRAE 90.1-2022) against the wall sections and the energy documentation, and produce the located list of internal inconsistencies the team reconciles before submittal, so the set is not bounced at intake for the coherence failures the strict checker is known to reject. Second, the AI-generated response to the first round of plan-check comments: the AI-organized, AI-drafted packet, with every code citation and compliance interpretation verified by the architect against the published, adopted code before it goes back.

Produce, alongside the artifacts, the discipline analysis that makes them safe. State the two jobs and why they carry different trust: the coherence checking the AI does well and the team can act on, versus the code interpretation the architect must own and verify because the AI fabricates citations in a confident voice indistinguishable from correct ones. State the rule that every code citation in the QA report's findings, in the submittal, and in the response packet is verified against the real adopted code, starting with whether the cited section exists, because the architect's stamp certifies the code analysis and a fabricated citation under a stamp is a problem far larger than a rejected sheet. This is the tier-three code interpretation the program reserves to the licensed professional, met here at its most exacting test, the expert plan checker reading every citation against the real code.

The lasting product is a permit workflow that uses AI to win the consistency pass, catching the avoidable coherence rejections in the office before they cost a multi-week cycle, and to turn the response round-trip faster with an AI-drafted packet, while the architect of record owns every code interpretation the submittal and the responses stand on. The professional who masters this gets the AI's speed on the coherence checking and the packet assembly, real and schedule-saving, without the catastrophe of a stamped fabrication, because the workflow places the consistency-checking and drafting with the AI, where its speed is the value, and the code interpretation with the architect, where the stamp and the published code govern. The AI checks whether the documents agree and drafts the packet fast; the architect says what the code requires, because the code interpretation is the stamped act, and behind a permit set read by an expert checker, a confident fabrication is the one error the AI must never be allowed to commit.

Key Takeaways

• Plan check is the AHJ's review of the permit set against the adopted codes, and the expense is the round-trips: in a busy jurisdiction each avoidable rejection sends the set back into a queue measured in weeks, so the architect's goal is to minimize the cycles, ideally a first submittal approved or returned with only minor comments.
• Rejections come in two kinds: internal inconsistencies (egress not matching the area calcs on A-001, the accessible route disagreeing with the detail, the energy form citing different envelope values than the wall sections), which are coherence failures, and substantive code issues (egress truly insufficient, an assembly truly failing the energy code), which are compliance failures requiring code interpretation.
• AI is strong on the coherence failures and dangerous on the compliance ones: the pre-submittal QA pass cross-checks the egress, area calcs, accessibility (ANSI A117.1 / ADA), and envelope and energy (IECC 2024 / ASHRAE 90.1-2022) numbers across the set and flags the inconsistencies that live in the seams between sheets different people drew, faster than manual coordination.
• The hard line: an AI asked about code produces confident, fabricated citations (citing an IBC section that does not exist, conflating occupancies, quoting the wrong code edition) in the same authoritative voice it uses for real ones, so it can check whether the documents agree but must never be trusted to say what the code requires.
• A fabricated citation under the architect's stamp is worse than the inconsistency the QA pass prevents: the expert plan checker who knows the real code sees a citation to a nonexistent section, which signals the submittal's code analysis cannot be trusted, invites deeper scrutiny, and exposes the architect whose stamp certifies the analysis to a problem far larger than a rejected sheet.
• Keep the two jobs separate by trust: coherence claims (a flagged sheet-to-sheet mismatch) are verifiable on their face and the team can act on them as a fast first pass, while every compliance and citation claim is a draft the architect verifies against the published, adopted code, starting with whether the cited section even exists.
• The plan-check response packet follows the same division: the AI accelerates the assembly and drafting (organizing comments, drafting responses, locating addressing sheets, formatting for the AHJ) to turn the round-trip faster, but the substance of each response is a compliance claim under the stamp that the architect verifies against the real code, because a response that cites a fabricated section deepens the checker's distrust.
• The artifact: a pre-submittal QA report (AI-found internal inconsistencies, located and reconciled before submittal) and an AI-drafted plan-check response packet (every citation and interpretation architect-verified), embodying the rule that the AI checks whether the documents agree and drafts fast, while the architect of record owns the tier-three code interpretation the stamp certifies, met here at its most exacting test before an expert plan checker.