email-construction — Claude Code skill: what it does, how to install
email-construction generates structured construction emails: RFI responses, submittal transmittals, change order notices, and meeting invites.
MIT 115 installs ★ 434 updated 2026-10-19
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill email-construction -a claude-codeWhat email-construction does
The skill provides Python templates for construction project communication. Using dataclasses, it formats subjects and bodies for five specific scenarios: RFI responses, submittal transmittals, meeting notices, change order notifications, and daily site reports.
Each template handles domain details. Submittal emails list individual items with copy counts. Change order alerts format negative values as credits and flag pending requests with high priority. Meeting templates include agenda points alongside structured calendar invite metadata for safety, coordination, or OAC sessions.
Running the generator functions requires python3 in the system path. The skill supports macOS, Linux, and Windows environments.
What it helps with
- draft an RFI response email with referenced attachments
- prepare a submittal transmittal listing drawing copies and review deadlines
- generate an OAC or subcontractor meeting invite with agenda items
- create a change order notification showing cost and schedule impact
Example prompts for the agent
- Draft an email response for RFI #42 on the Riverside project
- Create a submittal transmittal for spec section 09-2200 with 3 drawing copies
- Write a pending change order notification for CO #08 detailing the $14,500 cost impact
How to install email-construction
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill email-construction -a claude-code2Manually: put the files in place
~/.claude/skills/email-construction/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/email-construction/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill email-construction -a codex2Manually: put the files in place
.agents/skills/email-construction/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill email-construction -a cursor2Manually: put the files in place
.cursor/skills/email-construction/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction 4_DDC_Curated/Document-Generation/email-construction2Manually: put the files in place
.github/skills/email-construction/SKILL.md1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill email-construction -a gemini-cli2Platform CLI
gemini skills install https://github.com/datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --path 4_DDC_Curated/Document-Generation/email-constructionManually: put the files in place
.devin/skills/email-construction/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill email-construction -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about email-construction
How do I install email-construction in Claude Code?
Run npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill email-construction -a claude-code. The skill file will be placed in ~/.claude/skills/email-construction/SKILL.md.
What construction workflows are covered?
It covers RFI answers, submittal transmittals, meeting invitations, change order updates, and daily construction reports.
What dependencies does this skill require?
Your system needs python3 available in PATH. It runs on macOS, Linux, and Windows.
Source text
SKILL.md · MIT
---
name: "email-construction"
description: "Email generation for construction workflows: RFI responses, submittal transmittals, meeting notices, change order notifications. Professional templates with context-aware content."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw": {"emoji": "📄", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
---
# Email Generation for Construction
## Overview
Generate professional construction emails with proper formatting, context, and attachments handling. Templates for common construction communication workflows.
## Construction Use Cases
### 1. RFI Response Email
Generate professional RFI response emails.
```python
from dataclasses import dataclass
from datetime import datetime
from typing import Optional, List
@dataclass
class RFIResponse:
rfi_number: str
project_name: str
subject: str
question: str
response: str
responder_name: str
responder_title: str
attachments: List[str] = None
cc_list: List[str] = None
def generate_rfi_response_email(rfi: RFIResponse) -> dict:
"""Generate RFI response email."""
subject = f"RE: RFI #{rfi.rfi_number} - {rfi.subject}"
body = f"""Dear Project Team,
Please find below our response to RFI #{rfi.rfi_number}.
**Project:** {rfi.project_name}
**RFI Number:** {rfi.rfi_number}
**Subject:** {rfi.subject}
**Date:** {datetime.now().strftime('%B %d, %Y')}
---
**QUESTION:**
{rfi.question}
---
**RESPONSE:**
{rfi.response}
---
Please proceed accordingly. If you have any questions regarding this response, please contact us.
{"**Attachments:**" + chr(10) + chr(10).join(f"- {a}" for a in rfi.attachments) if rfi.attachments else ""}
Best regards,
{rfi.responder_name}
{rfi.responder_title}
"""
return {
'subject': subject,
'body': body,
'cc': rfi.cc_list or [],
'attachments': rfi.attachments or []
}
```
### 2. Submittal Transmittal Email
Generate submittal transmittal emails.
```python
@dataclass
class SubmittalTransmittal:
submittal_number: str
project_name: str
spec_section: str
description: str
items: List[dict]
action_required: str
due_date: str
sender_name: str
sender_company: str
def generate_submittal_email(submittal: SubmittalTransmittal) -> dict:
"""Generate submittal transmittal email."""
subject = f"Submittal {submittal.submittal_number} - {submittal.spec_section} - {submittal.description}"
items_list = "\n".join(
f" {i+1}. {item['description']} ({item.get('copies', 1)} copies)"
for i, item in enumerate(submittal.items)
)
body = f"""Dear Design Team,
Please find attached Submittal {submittal.submittal_number} for your review.
**Project:** {submittal.project_name}
**Submittal No:** {submittal.submittal_number}
**Spec Section:** {submittal.spec_section}
**Description:** {submittal.description}
**Items Transmitted:**
{items_list}
**Action Required:** {submittal.action_required}
**Response Requested By:** {submittal.due_date}
Please review and return with your comments at your earliest convenience.
If you have any questions, please don't hesitate to contact us.
Best regards,
{submittal.sender_name}
{submittal.sender_company}
"""
return {
'subject': subject,
'body': body,
'priority': 'normal'
}
```
### 3. Meeting Notice Email
Generate meeting invitation emails.
```python
@dataclass
class MeetingNotice:
meeting_type: str # 'OAC', 'Subcontractor', 'Safety', 'Coordination'
project_name: str
date: str
time: str
location: str
virtual_link: Optional[str]
agenda_items: List[str]
attendees: List[str]
organizer_name: str
def generate_meeting_notice(meeting: MeetingNotice) -> dict:
"""Generate meeting notice email."""
subject = f"{meeting.meeting_type} Meeting - {meeting.project_name} - {meeting.date}"
agenda = "\n".join(f" {i+1}. {item}" for i, item in enumerate(meeting.agenda_items))
location_info = meeting.location
if meeting.virtual_link:
location_info += f"\n Virtual Option: {meeting.virtual_link}"
body = f"""Dear Team,
You are invited to the {meeting.meeting_type} Meeting for {meeting.project_name}.
**Meeting Details:**
- **Date:** {meeting.date}
- **Time:** {meeting.time}
- **Location:** {location_info}
**Agenda:**
{agenda}
**Attendees:**
{', '.join(meeting.attendees)}
Please confirm your attendance by replying to this email.
If you cannot attend, please send a delegate and notify the organizer.
Regards,
{meeting.organizer_name}
Project Manager
"""
return {
'subject': subject,
'body': body,
'to': meeting.attendees,
'calendar_invite': {
'start': f"{meeting.date} {meeting.time}",
'duration': 60,
'location': meeting.location
}
}
```
### 4. Change Order Notification
Generate change order notification emails.
```python
@dataclass
class ChangeOrderNotification:
co_number: str
project_name: str
description: str
amount: float
schedule_impact: str
reason: str
status: str # 'Pending', 'Approved', 'Rejected'
sender_name: str
sender_title: str
def generate_change_order_email(co: ChangeOrderNotification) -> dict:
"""Generate change order notification email."""
subject = f"Change Order #{co.co_number} - {co.status} - {co.project_name}"
amount_str = f"${co.amount:,.2f}"
if co.amount < 0:
amount_str = f"(${abs(co.amount):,.2f}) Credit"
body = f"""Dear Project Team,
This email is to notify you of Change Order #{co.co_number} for {co.project_name}.
**Change Order Details:**
- **CO Number:** {co.co_number}
- **Status:** {co.status}
- **Description:** {co.description}
**Financial Impact:**
- **Amount:** {amount_str}
**Schedule Impact:**
- {co.schedule_impact}
**Reason for Change:**
{co.reason}
{"Please review the attached documentation and provide your approval." if co.status == 'Pending' else ""}
{"This change order has been approved. Please proceed accordingly." if co.status == 'Approved' else ""}
If you have any questions, please contact the project team.
Best regards,
{co.sender_name}
{co.sender_title}
"""
return {
'subject': subject,
'body': body,
'priority': 'high' if co.status == 'Pending' else 'normal',
'flag': co.status == 'Pending'
}
```
### 5. Daily Report Email
Generate daily report distribution email.
```python
@dataclass
class DailyReportEmail:
project_name: str
report_date: str
report_number: int
weather: str
workforce_total: int
work_summary: List[str]
issues: List[str]
sender_name: str
def generate_daily_report_email(report: DailyReportEmail) -> dict:
"""Generate daily report distribution email."""
subject = f"Daily Report #{report.report_number} - {report.project_name} - {report.report_date}"
work_items = "\n".join(f"• {item}" for item in report.work_summary)
issues_text = "\n".join(f"• {issue}" for issue in report.issues) if report.issues else "None"
body = f"""Daily Construction Report
**Project:** {report.project_name}
**Date:** {report.report_date}
**Report #:** {report.report_number}
---
**Weather:** {report.weather}
**Total Workforce:** {report.workforce_total} workers on-site
---
**Work Completed:**
{work_items}
---
**Issues/Delays:**
{issues_text}
---
Full report attached. Please contact the site office with any questions.
{report.sender_name}
Site Superintendent
"""
return {
'subject': subject,
'body': body,
'attachments': [f'Daily_Report_{report.report_number}.pdf']
}
```
### 6. Delay Notice Email
Generate formal delay notification.
```python
@dataclass
class DelayNotice:
project_name: str
contract_number: str
delay_type: str # 'Excusable', 'Non-Excusable', 'Compensable'
cause: str
affected_activities: List[str]
original_completion: str
revised_completion: str
days_impacted: int
mitigation_plan: str
sender_name: str
sender_title: str
def generate_delay_notice_email(delay: DelayNotice) -> dict:
"""Generate formal delay notice email."""
subject = f"NOTICE OF DELAY - {delay.project_name} - {delay.days_impacted} Days"
activities = "\n".join(f" - {a}" for a in delay.affected_activities)
body = f"""NOTICE OF DELAY
**Project:** {delay.project_name}
**Contract No:** {delay.contract_number}
**Date:** {datetime.now().strftime('%B %d, %Y')}
---
Dear Owner/Owner's Representative,
In accordance with the contract requirements, this letter serves as formal notice of a delay to the project schedule.
**Delay Classification:** {delay.delay_type}
**Cause of Delay:**
{delay.cause}
**Affected Activities:**
{activities}
**Schedule Impact:**
- Original Completion Date: {delay.original_completion}
- Revised Completion Date: {delay.revised_completion}
- Calendar Days Impacted: {delay.days_impacted}
**Mitigation Plan:**
{delay.mitigation_plan}
We request a meeting to discuss this matter and coordinate recovery efforts. Please contact us at your earliest convenience.
This notice is provided without prejudice to any rights or remedies available under the contract.
Respectfully,
{delay.sender_name}
{delay.sender_title}
"""
return {
'subject': subject,
'body': body,
'priority': 'high',
'read_receipt': True,
'delivery_receipt': True
}
```
## Email Sending Integration
```python
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
class ConstructionEmailSender:
"""Send construction emails via SMTP."""
def __init__(self, smtp_server: str, smtp_port: int, username: str, password: str):
self.smtp_server = smtp_server
self.smtp_port = smtp_port
self.username = username
self.password = password
def send(self, to: List[str], email_data: dict, from_addr: str = None):
"""Send email with optional attachments."""
msg = MIMEMultipart()
msg['From'] = from_addr or self.username
msg['To'] = ', '.join(to)
msg['Subject'] = email_data['subject']
if email_data.get('cc'):
msg['Cc'] = ', '.join(email_data['cc'])
if email_data.get('priority') == 'high':
msg['X-Priority'] = '1'
msg.attach(MIMEText(email_data['body'], 'plain'))
# Add attachments
for attachment_path in email_data.get('attachments', []):
with open(attachment_path, 'rb') as f:
part = MIMEApplication(f.read())
part.add_header('Content-Disposition', 'attachment',
filename=attachment_path.split('/')[-1])
msg.attach(part)
# Send
with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
server.starttls()
server.login(self.username, self.password)
recipients = to + email_data.get('cc', [])
server.sendmail(msg['From'], recipients, msg.as_string())
```
## Integration with DDC Pipeline
```python
# Example: Auto-generate RFI response email from RFI log
import pandas as pd
# Load RFI log
rfi_log = pd.read_excel("RFI_Log.xlsx")
# Get pending RFI
pending_rfi = rfi_log[rfi_log['status'] == 'Response Ready'].iloc[0]
# Generate email
rfi = RFIResponse(
rfi_number=pending_rfi['rfi_number'],
project_name=pending_rfi['project'],
subject=pending_rfi['subject'],
question=pending_rfi['question'],
response=pending_rfi['response'],
responder_name='John Smith',
responder_title='Project Architect',
attachments=['SK-001.pdf']
)
email_data = generate_rfi_response_email(rfi)
print(f"Subject: {email_data['subject']}")
print(email_data['body'])
```
## Email Templates Library
Common email templates for construction:
| Template | Use Case |
|----------|----------|
| RFI Response | Responding to Requests for Information |
| Submittal Transmittal | Sending submittals for review |
| Meeting Notice | OAC, subcontractor, safety meetings |
| Change Order | CO notifications and approvals |
| Daily Report | Daily report distribution |
| Delay Notice | Formal delay notifications |
| Payment Application | Pay app submissions |
| Punch List | Punch list item notifications |
| Closeout | Warranty and closeout docs |
## Resources
- **Professional Email Writing**: Keep emails concise and action-oriented
- **Construction Email Best Practices**: Always include project name and reference numbers
- **Legal Considerations**: Delay notices may have contractual requirements
© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction