8 Claude Skills for Construction (and What They Do)

Most contractors who get started with Claude for construction hit the same wall. The same task gives two different results, and nothing you teach it carries over to the next chat. Skills fix that. These are the eight I run on every project, demonstrated live in the video above, ordered the way you meet them on a project: from the first run on a new bid folder through to handover.

Key takeaways

• A Claude skill is a stored, repeatable workflow: your process, your examples and your output format, captured once and reused on every project.
• The eight skills: project indexer, go/no-go, reconciliation check, contract review, procurement packaging, Gantt chart, document control and O&M manual.
• The trust boundary is the same in every one. Claude extracts, structures, cross-checks and drafts. You own every judgment and every number.
• Start with the project indexer. Every other skill runs faster and more accurately on an indexed folder.

What is a Claude skill?

A Claude skill is a nested set of instructions stored in your Claude account: the workflow you follow, the examples that show what good looks like, and the output format you want back. Instead of re-explaining a task in every chat, you name the skill and it runs your process the same way every time.

My contract review skill is a good picture of the shape. It holds my review workflow, a set of worked examples, the contract positions I accept and the register format I want the findings in. The next time a contract comes in, I upload it and say “review my contract using my contract review skill”, and the output arrives structured my way. As I say in the video, “You basically teach Claude, instruct Claude how to do that once. You capture that in a skill.”

This post is the library: what each of the eight skills does, where the AI stops and you take over, and when to reach for each one. If you want to write your own from scratch, how to build a Claude skill for construction covers the build side.

The eight skills at a glance

#	Skill	What it does	What stays with you
1	Project indexer	Summarises every file and drawing into text Claude reads fast	Confirming summaries match the documents
2	Go/no-go	Condenses a bid package into a scope and risk summary	The bid decision
3	Reconciliation check	Sweeps your finished estimate for gaps and errors	Every quantity and price
4	Contract review	Compares the contract to your acceptable terms, drafts the departures register	Clause verification and the negotiation
5	Procurement packaging	Requirements register, package register and scopes of work in three checked steps	The packaging strategy
6	Gantt chart	Builds a first-cut schedule from your package register	Sequence logic and durations
7	Document control	Sweeps project email and updates registers on a routine	Spot-checking the entries
8	O&M manual	Compiles specs and product data into the handover manual	Filling the gaps it highlights

1. Project indexer

The project indexer reads every document in a project folder and writes concise text summaries plus a CLAUDE.md file, a roadmap that tells Claude where things live and how to read them. It is a meta skill: it does no construction work itself, it makes every other skill faster and more accurate.

Without it, every question forces Claude to re-read a folder of PDFs, convert them to text and burn time and tokens on processing it has already done, and long tasks are where it gets confused. Drawings get special treatment. “Construction drawings are actually surprisingly hard for AI to read, because the visual analysis is not as good as the text analysis,” as I explain in the video. So the indexer splits the set, analyses each sheet individually and writes a text summary of what is on it, which is what Claude pulls from later instead of re-reading the drawing and risking a hallucinated read. Run it once per document set, re-run it when a revision arrives, and add project-specific rules to the CLAUDE.md as you go.

2. Go/no-go

The go/no-go skill takes a new bid package and produces a concise summary of scope, key inclusions and exclusions, unusual requirements and headline contract terms, built to support one decision: whether to bid. Claude condenses the documents. The decision itself stays with your team.

In the video I run it on a real bid set: an eight-storey commercial office development of roughly 12,500 square metres. Out the other end came a go/no-go summary sheet in Excel and a five-slide summary deck covering the scope, key exclusions like the fit-out and loose furniture, the contract form, payment terms and the risks worth a closer look. That is hundreds of bid documents condensed into something you can take into a bid meeting. One expectation to set: full workflow runs like this are not instant. Most take 5 to 10 minutes.

3. Reconciliation check (the estimate reviewer)

The reconciliation check reviews an estimate you have already finished. It re-reads the bid documents, checks every client requirement against your line items, hunts for implied scope gaps, double counts and calculation errors, then reports what it finds. It exists to stop you under-quoting. It never prices anything itself.

This is my favourite category of AI use: checking human work rather than replacing it. It is very hard to check your own estimate, and the classic miss is the implied gap, like concrete works priced with no allowance for the supply of concrete. The skill does a scope comprehensiveness check line by line against the client scope of works, then a separate pass for arithmetic. As I put it in the video, “the purpose of this skill is to basically prevent you from under-quoting projects.” It closes the loop on the workflow I cover in Claude for construction estimating: every requirement ends up either priced in the estimate or explicitly excluded in the offer.

4. Contract review

The contract review skill holds a library of your acceptable contract positions, extracts the clauses from a new head contract, compares the two and drafts a departures register. Clause-by-clause pattern matching at volume is exactly what AI does well. Verifying each clause citation and running the negotiation stay human.

The library is the real asset: a 10% cap on liquidated damages, no consequential loss, rise and fall, limited liability, set notice periods for delays. In my complete guide to quoting I work an example where the client terms arrive at $8,500 a day in liquidated damages, uncapped, against a standard position of a 10% cap. That is the kind of gap this skill surfaces, clause by clause, in a register you take into the negotiation. If you are going to spend money on a lawyer anywhere in this process, one option is to spend it building that library of acceptable terms once, rather than reviewing every contract from scratch.

5. Procurement packaging

The procurement packaging skill turns a head contract into procurement documents in three steps: extract every requirement into a register, break the requirements into a suggested package register, then draft a scope of works and pricing schedule per package. It stops for your review between every step.

Procurement suits AI because it is fundamentally a data transformation job: client scope, specifications and drawings in; packages, scopes and pricing schedules out. The discipline that matters is full allocation. Every requirement goes to exactly one package. Unallocated means a scope gap. Allocated twice means an overlap and an argument later. The packaging strategy itself stays yours, because it is subjective: some builders give underground utilities to the civil contractor, some to the electrical contractor, some free-issue the reinforcement and subcontract only the formwork and pour management. Feed the skill your historic package registers and it breaks projects down your way instead of a generic way. More packages usually means sharper prices but more interfaces to manage; that trade-off is a judgment call the skill asks you about rather than makes for you.

6. Gantt chart

The Gantt chart skill builds a first-cut project schedule from your bid documents, using the package register from the procurement skill as its structure. Scheduling is a lower-risk fit for AI than estimating: a schedule at bid stage is a forecast you edit, not a price you sign.

Skills can chain like this, with the output of one becoming context for the next, and the package register makes a natural work breakdown for the programme. Two cautions. First, output quality tracks input quality. In the video demo I gave it very little context, and the result leaned on AI-generated assumptions more than I would accept on a real bid. Second, duration still matters commercially even before liquidated damages enter the picture, because your time-driven costs hang off it. A 5-week error in anticipated duration can easily cost you $60,000 across supervision, temporary site facilities and ongoing plant hire. So treat the draft as a starting point, and put your own eyes on the sequence logic and durations before anything relies on them.

7. Document control

The document control skill runs on a routine rather than on demand. It scans the project email address, cross-references new correspondence against the correspondence register, and updates the project registers with anything new. A simple sweep, scheduled daily or weekly, so the registers stop going stale.

Registers are only useful when they are current, and keeping them current is exactly the kind of repetitive checking that never survives a busy week on site. Claude skills can be set to run on a routine, so this one works through the inbox on whatever cadence you choose and writes the updates back into the project folder. You still spot-check the entries; the skill does the sweep. In the video I set it up on a Gmail project address, but the pattern is the same on any inbox.

8. O&M manual

The O&M manual skill compiles the technical specifications, product data and contacts from a finished project into a templated operations and maintenance manual. Anything it cannot find it highlights in yellow for you to populate, so the gaps are visible instead of silently missing.

Handover documentation is the job everyone leaves to the end of the project and nobody enjoys. The skill assembles the manual structure and everything it can verify from the project record, references the right contacts, and marks the holes. The default is a typical O&M structure, but you can customise it against previous manuals your clients have accepted. Same honest pattern as the rest of the library: compile what is grounded in the project documents, highlight where human input is still owed.

Common mistakes with Claude skills

• Running skills on a raw folder. Index first. Every skill downstream reads faster and hallucinates less on an indexed project.
• Leaving the skills generic. Without your acceptable terms, your historic package registers and your scope-of-works examples, the output is generic too. The customisation is where the value is.
• Skipping the checkpoints. The procurement skill stops between steps for a reason. Approving output you have not read defeats the design.
• Letting the skill own a number. Quantities, rates, margin and the bid decision are yours. The skills index, extract, populate and cross-check.
• Expecting instant answers. A full run over a bid folder takes 5 to 10 minutes. Start it, do something else, come back and review.

All eight live in the ContractorOS community classroom, ready to download and customise with your own data. Every one is demonstrated end to end in the full video above, including live runs on a real bid package. Worth watching before you set up your own versions.