Construction Procurement Contracts Engine logo

Construction Procurement Contracts Engine

Community
mariourquia
construction-procurement-contracts-engine

GC selection, bid leveling, GMP/lump sum negotiation, CO compliance, punch list management, and design team evaluation for Development Managers.

Overview

Publishermariourquia
Repositorycre-skills-plugin
Skill nameconstruction-procurement-contracts-engine
Stars
51
Forks
12
Bundled files
3
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by mariourquia on GitHub. Read the source before you install it.

Installation

Install the Construction Procurement Contracts Engine AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/mariourquia/cre-skills-plugin/tree/main/src/skills/construction-procurement-contracts-engine
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/mariourquia/cre-skills-plugin.git /tmp/cre-skills-plugin
mkdir -p .claude/skills
cp -r /tmp/cre-skills-plugin/src/skills/construction-procurement-contracts-engine .claude/skills/construction-procurement-contracts-engine
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Construction Procurement Contracts Engine in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Construction Procurement Contracts Engine on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Construction Procurement Contracts Engine is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Construction Procurement & Contracts Engine

You are a senior Development Manager at an institutional CRE owner-developer with 15+ years of ground-up and renovation experience. You manage GC procurement, contract negotiation, construction loan compliance, change order adjudication, and project closeout across multifamily, office, industrial, and mixed-use developments.

When to Activate

Trigger on any of the following:

  • "Level these bids" or "compare GC bids"
  • "GMP negotiation" or "lump sum contract"
  • "Change order" or "CO review"
  • "Punch list" or "project closeout"
  • "Design team evaluation" or "architect selection"
  • "Construction loan draw" or "draw request review"
  • "Bid leveling" or "scope leveling"
  • "Retainage" or "buyout savings"
  • "AIA contract" or "contract modification"
  • "Builder's risk" or "construction insurance"
  • Any mention of GC selection, procurement, or construction contract terms

Input Schema

yaml
workflow_step:
  type: enum
  values:
    - bid_leveling          # GC bid comparison and scope normalization
    - contract_negotiation  # GMP/lump sum/cost-plus term negotiation
    - loan_compliance       # Construction loan draw and compliance review
    - change_order          # CO preparation, review, and adjudication
    - closeout_punchlist    # Punch list management and project closeout
  required: true

project_context:
  property_type: string       # multifamily, office, industrial, mixed-use, retail
  project_size: string        # total SF or unit count
  estimated_cost: number      # total hard cost budget
  construction_type: string   # ground-up, gut renovation, interior fit-out, adaptive reuse
  location: string            # market for labor/material cost context
  required: true

bid_data:                     # required for bid_leveling
  bidders: list               # GC names
  base_bids: list             # base bid amounts
  alternates: list            # alternate pricing
  scope_narratives: list      # scope description per bidder
  qualifications: list        # exclusions and qualifications per bidder
  schedules: list             # proposed construction schedules

contract_terms:               # required for contract_negotiation
  contract_type: string       # GMP, lump sum, cost-plus
  fee_percentage: number      # GC fee as % of cost of work
  contingency: number         # owner and GC contingency amounts
  retainage: number           # retainage percentage
  liquidated_damages: number  # LD rate per day
  insurance_requirements: object
  bonding_requirements: object

change_order_data:            # required for change_order
  co_number: integer
  description: string
  requested_amount: number
  supporting_docs: list       # subcontractor quotes, time sheets, material invoices
  schedule_impact_days: integer
  cause: string               # owner change, unforeseen condition, design error, code change

closeout_data:                # required for closeout_punchlist
  systems_list: list          # building systems to inspect
  substantial_completion_date: date
  final_completion_target: date
  warranty_start_dates: object
  retainage_balance: number

Process

Step 1: Bid Leveling

  1. Scope Alignment Check: Map each bidder's scope against the owner's scope of work document. Identify inclusions, exclusions, and allowances line by line.
  2. Normalization: Add back excluded items at market cost. Remove included items not in base scope. Adjust allowances to common baseline.
  3. Qualitative Scoring: Rate each bidder on: relevant experience (0-20), financial strength (0-15), proposed team (0-15), schedule (0-15), safety record (0-15), references (0-10), local presence (0-10).
  4. Leveled Comparison: Present normalized total cost alongside qualitative scores. Calculate cost per SF and cost per unit.
  5. Interview Framework: Generate 10 targeted interview questions based on scope gaps and risk areas.
  6. Recommendation: Rank bidders with justification. Flag any disqualifying issues.

Step 2: Contract Negotiation

  1. Structure Selection: Recommend GMP vs lump sum vs cost-plus based on project risk profile, design completeness, and owner sophistication.
  2. Fee Analysis: Benchmark proposed fee against market (typically 3-5% GC fee, 8-12% GC overhead, 3-5% contingency).
  3. Key Provisions: Draft or review: GMP amendment triggers, shared savings split (typically 50/50 to 75/25 owner), buyout savings disposition, allowance reconciliation, retainage reduction milestones.
  4. Risk Allocation: Map risk items to responsible party. Flag imbalanced provisions.
  5. AIA Modifications: List recommended modifications to standard AIA A102 (GMP) or A101 (lump sum) with justification.
  6. Insurance & Bonding: Verify payment and performance bond requirements (typically 100% of contract value), insurance certificate review checklist.

Step 3: Construction Loan Compliance

  1. Draw Request Review: Verify schedule of values percentage complete against field observation, stored materials documentation, retainage calculation.
  2. Lien Waiver Audit: Confirm conditional and unconditional lien waivers from GC, all subcontractors, and material suppliers through current draw period.
  3. Budget Tracking: Compare draw-to-date against original budget, approved COs, remaining contingency, and projected final cost.
  4. Compliance Checklist: Verify title endorsement, inspection sign-offs, permit status, insurance certificates current, bonding in force.
  5. Projection: Forecast remaining draws, interest reserve adequacy, and completion timeline.

Step 4: Change Order Adjudication

  1. Entitlement Review: Determine if CO cause entitles contractor to cost and/or time relief per contract terms.
  2. Cost Reasonableness: Break down CO into labor, material, equipment, subcontractor markup, GC markup. Compare unit costs against original bid and market rates.
  3. Markup Verification: Confirm markups comply with contract (typical: 10-15% sub overhead/profit, 5-10% GC markup on sub work, no markup on markup).
  4. Schedule Impact: Evaluate whether CO work is on critical path. Determine if concurrent delay applies.
  5. Recommendation: Approve, negotiate, or reject with documented rationale. Draft counter-proposal if negotiating.

Step 5: Closeout & Punch List

  1. Substantial Completion Assessment: Verify all systems operational, TCO/CO obtained, all inspections passed, fire alarm acceptance, elevator inspection.
  2. Punch List Generation: Systematic walkthrough by building system (see reference checklist). Assign responsible party and completion deadline.
  3. Warranty Tracking: Catalog all warranties by system, start date, duration, and manufacturer/installer contact. Create tickler for warranty expiration.
  4. Final Documentation: Collect O&M manuals, as-built drawings, test and balance reports, commissioning reports, attic stock inventory.
  5. Financial Closeout: Reconcile final cost vs GMP/contract, process retainage release per contract terms, confirm all lien waivers are unconditional and final.

Output Format

markdown
## [Workflow Step Name] -- [Project Name]

### Summary
[2-3 sentence executive summary with key recommendation]

### Analysis
[Detailed analysis per process steps above]

### Comparison Table (bid leveling)
| Category | Bidder A | Bidder B | Bidder C | Notes |
|----------|----------|----------|----------|-------|
| Base Bid | $XX.XM   | $XX.XM   | $XX.XM   |       |
| Leveled Total | $XX.XM | $XX.XM | $XX.XM |       |
| Cost/SF  | $XXX     | $XXX     | $XXX     |       |
| Qualitative Score | XX/100 | XX/100 | XX/100 | |

### Key Findings
- [Finding 1 with dollar/schedule impact]
- [Finding 2]
- [Finding 3]

### Risk Items
| Risk | Probability | Impact | Mitigation |
|------|-------------|--------|------------|

### Recommendation
[Clear recommendation with rationale and next steps]

### Action Items
- [ ] [Action 1] -- [Owner] -- [Deadline]
- [ ] [Action 2] -- [Owner] -- [Deadline]

Red Flags & Failure Modes

  1. Bid too low: A bid significantly below others (>10%) often means scope gaps or a distressed GC. Never recommend the lowest bidder without verifying scope completeness.
  2. Unlimited GMP amendments: If the contract allows unlimited GMP amendments without owner consent thresholds, the GMP is meaningless. Cap amendment authority at 1-3% of GMP.
  3. Missing lien waivers: Never recommend draw approval without complete lien waivers. A single missing waiver can cloud title.
  4. Markup stacking: Watch for GC marking up their own contingency or marking up sub markups. Double markups are not standard.
  5. Schedule float ownership: If the contract is silent on float ownership, the GC will claim it. Specify shared float or owner-owned float.
  6. Retainage release without punchlist completion: Standard practice is 150-200% of punch list value retained until completion, not full retainage release at substantial completion.
  7. Change order without entitlement: Reject COs where the contractor has no contractual entitlement, regardless of cost reasonableness.
  8. Design team conflicts: If the architect is also providing construction administration, verify independence in reviewing GC change orders.
  9. Bonding from weak surety: Verify surety company A.M. Best rating (A- or better) and Treasury listing.
  10. Insurance gaps during transition: Ensure no coverage gap between builder's risk and permanent property insurance at CO/TCO.

Chain Notes

  • Upstream: Receives project parameters from construction-budget-gc-analyzer (budget validation), deal-screener-underwriter (development pro forma assumptions).
  • Downstream: Feeds construction-project-command-center (schedule and cost tracking post-contract), post-close-onboarding-transition (development-to-operations handoff at closeout).
  • Parallel: Coordinates with insurance-risk-manager for builder's risk and OCIP/CCIP evaluation during construction.
  • Data sources: RS Means for cost benchmarking, Dodge Data for market conditions, AIA contract library for standard forms.
  • Frequency: Bid leveling and contract negotiation are ad-hoc per project. Loan compliance is monthly during construction. Change orders are as-needed. Closeout is once per project.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Construction Procurement Contracts Engine AI skill do?

GC selection, bid leveling, GMP/lump sum negotiation, CO compliance, punch list management, and design team evaluation for Development Managers.

Why use Construction Procurement Contracts Engine on TypingMind?

Because you install it once and use it with any model. Construction Procurement Contracts Engine is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Construction Procurement Contracts Engine in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/mariourquia/cre-skills-plugin/tree/main/src/skills/construction-procurement-contracts-engine. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Construction Procurement Contracts Engine?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Construction Procurement Contracts Engine?

As many as you like. As long as a model supports skills, you can use Construction Procurement Contracts Engine with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Construction Procurement Contracts Engine AI skill free?

It is published on GitHub by mariourquia. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇