When people first see Specset review a submittal, the moment they don't expect is the shop drawing one. They've watched plenty of tools read a product data sheet, pull a model number, and check it against a spec line. That part feels inevitable. But hand the same tool a 40-page set of fabrication drawings (steel connections, curtain wall sections, a door schedule that spans three sheets) and most of them quietly fall back to reading whatever text is embedded in the PDF and skip the drawing itself.
That's the part customers are surprised we actually do. So this post is about exactly that: how Specset reviews shop drawings, why it's harder than reviewing cut sheets, and what it means to do it properly.
Why shop drawings are the hard part
A submittal package is rarely one kind of thing. Product data submittals are mostly text and tables: datasheets, certifications, model numbers. Those are tractable: extract the values, match them to the spec, flag the misses.
Shop drawings are different. They're the contractor's or fabricator's interpretation of the design, drawn to be built from. The requirement you're checking against doesn't live in a sentence. It lives in a dimension, a section detail, a weld callout, a schedule cell, a keynote that points somewhere else on the sheet. The compliance question isn't "does this paragraph match that paragraph?" It's "does this drawing, as drawn, satisfy what the spec and the contract drawings require?"
That's why a text-only approach breaks down. You can OCR the title block and the notes, but you'll miss the gauge called out on a detail, the clearance that's dimensioned but not written, the schedule value on sheet 6 that contradicts sheet 14. The information that matters most on a shop drawing is frequently not in any text layer at all.
The honest test for any "AI submittal review" tool: hand it a shop drawing set with the requirements drawn rather than written, and see whether it catches a dimensional deviation. If it only reads the text, it can't.
What "reading the drawing" actually means
Specset treats a shop drawing as a drawing, not as a wrapper around some text. When a set comes in, the agent works through it sheet by sheet and reads the geometry, the schedules, the callouts, and the details, then verifies each against the governing requirement.
In practice that looks like three things working together.
Reading the geometry, not just the title block. Dimensions, clearances, gauges, thicknesses, and details on the drawing are checked against what the spec and the contract drawings actually require. If the spec calls for a minimum clearance and the shop drawing dimensions it tighter, that's a finding, even when no sentence on the sheet says so.
Cross-checking schedules and callouts across pages. Door schedules, equipment schedules, fixture counts, finish callouts, and keynotes get reconciled across the whole set. This is where a lot of real problems hide: a value that's right on the schedule but wrong where it's referenced, a callout that points to a detail that isn't there, a count that doesn't add up between two sheets.
Comparing against the contract drawings. Shop drawings exist to realize the design intent on the contract set. So the agent matches them back to that set, and flags deviations with the exact sheet and clause that proves the conflict. "This connection differs from detail 5/S-501" is a usable finding. "Something looks off" is not.
It commits to a status, every time
Reading the drawing is only useful if it ends in a decision. Every check the agent runs on a shop drawing lands as one of four statuses:
- Compliant. Meets the requirement, with cited evidence.
- Non-Compliant. A verifiable deviation from the spec or contract drawings.
- Missing Info. Required, but absent from the submittal.
- Not Applicable. Out of scope, or deferred to field.
There's no "needs a human to look at this" hatch. The agent has to pick a lane, and if it genuinely can't, it has to say why. That constraint is what makes the output actionable: every item on your screen is a decision you need to make, not a pile of "maybes" to wade through.
Three review directions, because drawings hide things
Specset reviews every submittal three ways, and shop drawings are exactly why the drawing-first pass exists.
| Review pass | The question it asks | What it catches on shop drawings |
|---|---|---|
| Spec-first | Does the submittal satisfy this written requirement? | Explicit spec clauses the drawing must meet |
| Drawing-first | Does the submittal satisfy each requirement on this sheet? | Schedules, callouts, and details that never appear in the written spec |
| Submittal-first | Does each part of this submittal hold up under the project's requirements? | Page-to-page contradictions, missing details, items nobody specced |
A spec-only review never thinks to look at the drawing-carried requirements: the schedules and details that aren't in the project manual at all. The drawing-first pass is built specifically to walk the sheet and ask, for each thing the drawing calls out, whether the submittal satisfies it. The submittal-first pass then catches the internal contradictions: the schedule on page 6 that disagrees with page 14, the detail that's referenced but never drawn.
All three passes' results then get consolidated. The agent dedupes findings across passes, classifies them, groups them by where they appear in the submittal, and produces a single flat list of issues, each with a one-line title, a cited analysis, and links back to the underlying checks.
The human stays in control
AI gets things wrong sometimes, and shop drawings (dense, idiosyncratic, fabricator-specific) are where it's most likely to. The right response isn't to pretend it doesn't happen; it's to make correcting it fast.
Every flagged issue has a Dismiss action with a reason: Not Applicable, Acceptable as is, or Incorrect Finding (the AI was wrong). You can add a comment, dismiss in bulk, and the overall compliance rollup updates as you go, so the verdict always reflects your actual decisions, not the model's first guess.
The goal isn't to remove the engineer. It's to flip the job from "read 40 pages and find the problems" to "review the problems the agent already found, and decide whether it got them right."
Output you can actually send
When the review is done, every finding on a shop drawing points to a specific spot on a specific sheet, and Specset renders the annotation directly on the document. Click an issue and you get the analysis on the left and the drawing on the right, opened to the page with the problem area highlighted.
From there you can take it offline two ways:
- An annotated PDF. The marked-up set with a hyperlinked table of contents up front and every annotation baked into the original drawings behind it. Send it to the sub, attach it to a response, drop it in the project folder.
- A detailed XLSX. A summary sheet, an issues sheet, and one sheet per status listing every check the agent ran with source, requirement, analysis, and page numbers. The Compliant sheet is the underrated one: it's the paper trail that proves what was checked and why it passed.
And because most teams manage the submittal of record in Procore or Autodesk Construction Cloud, the whole thing plugs into those. New submittals sync in automatically, the review kicks off when the package lands, and the results (approver response, summary comment, and both attachments) flow back to where your team already works.
The short version
Shop drawings are where submittal compliance actually lives, and they're the part most AI tools skip because reading a drawing is harder than reading text. Specset reads the drawing: the geometry, the schedules, the callouts, and the details, verified against the spec and the contract set, committed to a clear status, and shipped as something you can send.
If that's the part you didn't think AI could do yet, that's the part we built first.
If you'd like to see a real shop drawing set run through it, get in touch and we'll walk you through one.
Co-founder and CPO of Specset.