An ASI lands in your inbox at 3pm: the architect has issued a supplemental instruction changing a detail, and it is marked as a clarification with no cost or time impact. You know better. That "minor clarification" adds two days of rework to a trade that is already on the critical path, and if you do not say so, in writing, in the right form, within the right window, you have just absorbed the cost and the delay for free. This lesson is about using AI to respond to ASIs and bulletins fast enough that you actually capture the impact instead of eating it, while keeping the contractual judgment, what the impact is and what notice it requires, firmly in your own hands. It is the RFI workflow turned around: now you are the one responding, and the stakes are cost and schedule.

What an ASI Actually Is, and Why the Response Matters

An Architect's Supplemental Instruction is the design team's tool for issuing minor changes that, in the architect's view, do not change the contract sum or time. The phrase "in the architect's view" is the whole game, because the architect issues the ASI from the design side and does not carry your costs, your subcontractor commitments, or your schedule logic. Many ASIs truly are no-impact clarifications. Some are not, and the ones that are not become your problem precisely because they arrived labeled as if they were free. The response is where you either preserve your right to be made whole for a real impact or silently waive it.

This is why the ASI response is a higher-stakes document than it looks. It is not just a polite acknowledgment; it is the contractual act of asserting, when warranted, that an instruction labeled no-impact actually carries cost or schedule consequences, and of giving the notice the contract requires to preserve that position. Under AIA A201, a contractor who believes an instruction will affect the sum or time has notice obligations, including the notice of a potential change, and missing them can forfeit the entitlement. So responding to an ASI well is a real skill with real money attached, and it is exactly the kind of high-volume, language-heavy, contract-bound task where AI helps enormously, as long as the contractual determination stays human.

Where AI Helps on an ASI Response

The ASI response has a recognizable structure, and AI is strong on most of it. A solid response identifies the instruction, states whether you accept it as no-impact or assert an impact, and if you assert an impact, describes the cost and schedule consequences with enough specificity to support the position, all while giving any contractually required notice. The descriptive and narrative parts of that, turning your assessment of the impact into a clear, professional, well-structured impact statement, are language work the model does well and fast, especially with your firm's past impact statements as few-shot examples.

Concretely, once you have made the judgment that an ASI carries impact, AI can draft the impact narrative: a clear statement of what the instruction changes, how it affects the affected scope, what the cost and schedule consequences are, and a reservation of rights and notice consistent with the contract. It can pull your assessment into your firm's impact-statement format in seconds, where writing it from scratch under deadline is exactly the kind of task that gets rushed or skipped. The win is that the response actually gets written and sent on time, in good form, because the drafting friction that causes impacts to go unasserted is removed. The model does the writing; you supply the judgment and the facts it writes from, which is the same division as the RFI workflow.

Impacts go unasserted not because the PM did not notice them but because writing the response under deadline is friction. AI removes the friction, so the impact actually gets asserted in form and on time, which is where the money is.

The Two Judgments That Stay Yours

Two determinations in an ASI response are yours alone and must never be delegated to the model, because they are exactly where it fails. The first is the impact judgment itself: whether this ASI actually carries cost or schedule consequence, and how much. The model cannot know your subcontractor commitments, your crew loading, your critical path, or what this detail change really does to the trade in the field, so it cannot decide whether the ASI is no-impact or impactful. You make that call from your knowledge of the project; the model only writes up the call you made. Asking the model "does this ASI have an impact" is asking it to invent an answer it has no basis for, and it will, confidently.

The second is the contract notice judgment, identical to the RFI lesson's discipline. Whether and how you must give notice of a potential change is governed by your contract, and under A201 the relevant provisions around changes and the contractor's notice of a potential change carry their own requirements that the model conflates or invents. You determine, from your executed agreement, what notice the asserted impact requires and what window applies, and the model renders that language; it does not decide the clause or the deadline. Decide-then-draft applies exactly as it did for the RFI: you make both the impact determination and the notice determination, and the AI writes the response that records them. The response can be drafted in two minutes, but the two minutes of judgment behind it are entirely yours, and that is where the value and the protection both live.

Tying the Impact to the Executed Subcontract

A weak ASI impact statement asserts a vague impact; a strong one quotes the affected scope from the actual executed subcontract and shows precisely how the instruction changes what was bought. This specificity is what makes the impact defensible, and it is a place where AI both helps and must be watched. AI helps by drafting the narrative that connects the ASI to the subcontract scope once you provide the relevant subcontract language; it must be watched because if you let it characterize what the subcontract says from memory rather than from the actual document, it will paraphrase or invent scope language that does not match your executed agreement, which undermines the very specificity that makes the statement strong.

So the discipline is to feed the model the actual relevant subcontract scope language and instruct it to quote and reference it exactly, not to summarize what such a subcontract typically says. You provide the real scope text; the model weaves it into the impact narrative; you verify the quotation matches the executed subcontract. This produces an impact statement that says, in effect, the executed subcontract included this specific scope, the ASI changes it in this specific way, and the cost and schedule consequence is this, grounded in the actual contract language rather than a generic assertion. That grounding is what makes an owner or an architect take the impact seriously instead of dismissing it, and it is the difference between an impact statement that recovers the cost and one that gets waved off as boilerplate.

Naming the Fragnet That Captures the Delay

The schedule half of the impact statement has its own specificity requirement: a strong response does not just say "this causes delay," it identifies the fragnet, the fragmentary network of schedule activities, that captures how the ASI's delay propagates through the critical path. The fragnet is the schedule-side equivalent of quoting the subcontract scope: it is the specific, defensible demonstration that the delay is real and how it flows, rather than a bare assertion of lost days. We cover building fragnets and time impact analyses in depth in the scheduling chapter; here the point is that the ASI response should name the fragnet that will capture the delay, even if the full TIA comes later.

AI's role here is bounded and useful: it can draft the narrative that references the fragnet and describes the schedule impact in words, but it cannot build or validate the fragnet itself, which is schedule logic that a scheduler owns and that the model cannot reliably construct. So the response names the fragnet and describes the impact in language, the AI-drafted part, while the actual schedule analysis that proves the delay is the scheduler's work, verified against the real CPM. The pattern is consistent across both halves of the impact statement: AI writes the narrative that connects real, human-supplied specifics, the quoted subcontract scope and the named fragnet, into a clear, professional impact statement, and the humans own the specifics and the analysis that make the narrative true. The narrative is fast; the specifics it rests on are verified.

ASIs, Bulletins, and Knowing Which Instrument You Are Answering

ASIs are not the only minor-change instrument you respond to; bulletins and similar design-issued instructions travel under different names and sometimes different contractual weight, and a strong response starts by correctly identifying which instrument you are actually answering. A bulletin may bundle several changes, some clarifying and some substantive, and treating the whole bulletin as one no-impact item is how a real change buried in a bulletin gets absorbed. The discipline is to read each item in the instrument on its own and assess each for impact, rather than responding to the document's label.

AI can help with the triage here, and this is a legitimate use that respects the boundary: you can ask the model to break a multi-item bulletin into its individual instructions so you can assess each one separately, which is an organizing task it does well and which surfaces the items that might otherwise be skimmed past. What you do not do is ask the model which items have impact, because that is the impact judgment that remains yours. So the model decomposes the bulletin into a clean list of discrete instructions, and you walk the list applying your own impact judgment to each, then have the model draft responses for the ones that warrant them. This is the same pattern as the RFI duplicate check: AI organizes and surfaces, you judge and decide, and the organizing truly speeds the part of the work that is tedious without touching the part that requires your knowledge of the project. Correctly identifying the instrument and decomposing it is the first move, because you cannot assess an impact you did not separate out from the clarifications it was bundled with.

How Response Speed Changes Your Change-Management Posture

There is a strategic shift hidden in making ASI responses fast, the same kind of shift AI created for RFIs. When responding to an impactful ASI was a slow, friction-heavy task, PMs rationally triaged, they fought the big impacts and quietly absorbed the small ones because there was not time to write a defensible response to every minor instruction. That triage was a real cost, because the small absorbed impacts add up across a project into significant unrecovered margin, and they also weaken your position on the big ones, since a pattern of silently accepting small changes can be used to argue you treated changes casually.

When the response becomes fast, the triage calculus changes: you can now assert every legitimate impact, not just the ones big enough to justify the old drafting effort, which both recovers the small impacts directly and strengthens your overall change posture by establishing a consistent, documented practice of asserting impacts properly. This connects to a larger argument the change-management chapter develops, the cumulative-impact claim, where a series of individually-small changes together produce a disruption impact larger than their sum; a firm that documented each small impact contemporaneously is positioned to make that argument, while a firm that absorbed them silently is not. So the speed AI provides is not just convenience, it changes what change-management strategy is feasible, moving you from triaging which impacts to fight to documenting all of them, which is a materially stronger position. The judgment behind each assertion stays human; what changes is that you can now afford to exercise that judgment on every instruction instead of only the expensive ones.

The Applied Problem: Respond to a Mock ASI

Here is the exercise that builds the skill. Take a mock or real ASI that carries an impact, one labeled no-cost-no-time that actually affects a trade, and produce a complete impact-statement response using the workflow. Make the two judgments first: confirm the ASI carries impact and assess it, and determine from your contract what notice the asserted impact requires. Then have the AI draft a three-paragraph impact statement, and hold it to real specifics.

The three paragraphs should do specific work. The first identifies the ASI and states that, contrary to its no-impact label, it carries cost and schedule consequences, with the contractually required notice language you determined. The second quotes the affected scope from the executed subcontract and shows exactly how the ASI changes it, grounding the cost impact in the real contract language you provided. The third identifies the fragnet that captures the schedule delay and describes how the delay propagates, with the full TIA to follow. Then verify every specific: the subcontract quotation against the executed subcontract, the notice clause against your contract, and the schedule assertion against the real CPM and the scheduler's fragnet.

The deliverable is the verified three-paragraph impact statement plus the verification record, and the lasting product is a response workflow that lets you assert impacts you would otherwise have eaten because writing the response on time was too much friction. This is the document that turns a stream of "minor clarifications" from silent margin erosion into properly asserted, defensible impacts, and AI is what makes responding to all of them feasible instead of triaging which ones you have time to fight. The PM who can produce a grounded ASI impact statement in minutes responds to every impactful ASI instead of just the biggest ones, which over a project is real recovered margin, captured because the drafting friction that used to let impacts slip is gone while the judgment that makes the assertion defensible stayed entirely human.

Key Takeaways

• An ASI is the architect's tool for changes that, in the architect's view, carry no cost or time. Some truly do not; the ones that do become your problem because they arrived labeled as free, and the response is where you preserve or silently waive your right to be made whole.
• Impacts go unasserted not because the PM missed them but because writing the response under deadline is friction. AI removes the friction so the impact actually gets asserted, in form and on time, which is where the money is.
• Two judgments stay entirely yours: whether the ASI carries impact and how much (the model cannot know your subs, crews, or critical path), and what notice the contract requires (the model conflates and invents clauses). Decide-then-draft: you make both calls, the AI writes them up.
• Ground the cost impact in the executed subcontract: feed the model the actual scope language and have it quote it exactly, never summarize from memory, because the specificity is what makes the impact defensible rather than dismissible boilerplate.
• Ground the schedule impact in a named fragnet: the response names the fragnet that captures the delay, the AI drafts the narrative, but the scheduler owns and verifies the actual schedule logic against the real CPM. AI writes the narrative; humans own the specifics that make it true.
• The artifact: a three-paragraph impact statement responding to a mock impactful ASI, asserting the impact with required notice, quoting the subcontract scope, and naming the fragnet, with every specific verified against the source.
• The payoff is responding to every impactful ASI instead of triaging which to fight, turning a stream of "minor clarifications" from silent margin erosion into properly asserted, defensible impacts, because the drafting friction is gone while the judgment stayed human.