Never Walk Into a Meeting Unprepared Again: Build an AI That Briefs You Every Morning

Every morning, before your first meeting, your AI reads today's calendar and emails you a prep brief: who you're meeting, what you should know going in, smart questions to ask, and what outcome to aim for. You read it over coffee. You walk in ready. The whole thing runs automatically. This guide shows you exactly how to build it — no complex integrations, no OAuth headaches, just a Python script and a cron job.

What You'll Have When You're Done

How It Works (Plain English)

Every major calendar app — Google Calendar, Apple Calendar, Outlook — lets you export a private ICS feed URL. This is just a link that always points to your current calendar data. You can fetch it any time without logging in.

Our script fetches that URL each morning, parses today's meetings, and for each one sends the title, time, description, and attendee list to OpenAI. The AI reads all of that and writes you a prep note: what the meeting is probably about, what you should prepare, and what questions would make you look sharp.

Then it bundles all the prep notes into a single email and sends it to your inbox. You get one email, one read, and you're ready for the whole day.

What You Need

• Python 3.9+ — already installed on most Macs and Linux machines. Check with python3 --version.
• An OpenAI API key — sign up at platform.openai.com if you don't have one. You need $5 in credits maximum for months of use at this scale.
• Your calendar's private ICS URL — we'll get this in Step 1. Works with Google, Apple iCloud, Outlook, and any CalDAV calendar.
• An SMTP email account for sending — Gmail works perfectly. We'll use an App Password (not your real password).

That's it. No OAuth setup. No Google Cloud Console. No API keys beyond OpenAI.

Step-by-Step Setup (~25 Minutes)

The Full Script

Copy this exactly. Update the five config values at the top. Everything else is ready to go.

#!/usr/bin/env python3
"""
Meeting Briefer — reads today's calendar and emails you a prep brief.
Runs in ~20-30 seconds. Costs about $0.01-0.03 per run.
"""

import smtplib
import ssl
import requests
from datetime import date, datetime, timezone
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from icalendar import Calendar
from openai import OpenAI

# ─── CONFIG (edit these 5 values) ──────────────────────────────────────────

ICS_URL        = "YOUR_PRIVATE_ICS_URL_HERE"
OPENAI_API_KEY = "sk-..."
SMTP_EMAIL     = "[email protected]"       # Gmail address you send FROM
SMTP_PASSWORD  = "xxxx xxxx xxxx xxxx"  # App Password (not your real password)
TO_EMAIL       = "[email protected]"       # Where to send the briefing (can be same)

# ─── END CONFIG ─────────────────────────────────────────────────────────────

client = OpenAI(api_key=OPENAI_API_KEY)


def fetch_todays_meetings(ics_url: str) -> list[dict]:
    """Fetch ICS feed and return today's meetings sorted by start time."""
    response = requests.get(ics_url, timeout=15)
    response.raise_for_status()

    cal = Calendar.from_ical(response.content)
    today = date.today()
    meetings = []

    for component in cal.walk():
        if component.name != "VEVENT":
            continue

        dtstart = component.get("DTSTART")
        if not dtstart:
            continue

        # Handle both date-only and datetime events
        start_val = dtstart.dt
        if isinstance(start_val, datetime):
            start_date = start_val.date()
        else:
            start_date = start_val

        if start_date != today:
            continue

        # Extract time string
        if isinstance(start_val, datetime):
            # Normalize to local time display
            time_str = start_val.strftime("%I:%M %p").lstrip("0")
        else:
            time_str = "All day"

        # Extract attendees
        attendees_raw = component.get("ATTENDEE", [])
        if not isinstance(attendees_raw, list):
            attendees_raw = [attendees_raw]
        attendees = []
        for a in attendees_raw:
            cn = a.params.get("CN", "")
            if cn and cn.lower() not in (SMTP_EMAIL.lower(), "you"):
                attendees.append(cn)

        meetings.append({
            "title":       str(component.get("SUMMARY", "Untitled Meeting")),
            "time":        time_str,
            "description": str(component.get("DESCRIPTION", "")).strip()[:800],
            "location":    str(component.get("LOCATION", "")).strip(),
            "attendees":   attendees[:8],  # cap at 8 to keep prompt sane
        })

    meetings.sort(key=lambda m: m["time"])
    return meetings


def generate_prep_brief(meeting: dict) -> str:
    """Ask OpenAI to write a prep brief for one meeting."""
    attendee_str = ", ".join(meeting["attendees"]) if meeting["attendees"] else "not listed"

    prompt = f"""You are a sharp executive assistant. Prepare a concise meeting brief.

Meeting: {meeting['title']}
Time: {meeting['time']}
Attendees: {attendee_str}
Location/Link: {meeting['location'] or 'not specified'}
Description: {meeting['description'] or 'none provided'}

Write a brief with these four sections. Be specific and useful, not generic.

**What This Meeting Is Probably About**
One or two sentences based on the title, description, and attendees.

**What to Prepare**
2–3 concrete things to have ready or think about beforehand.

**Smart Questions to Ask**
3 questions that would make you look engaged and sharp in this meeting.

**Desired Outcome**
One sentence: what a successful outcome looks like.

Keep the whole thing under 200 words. Plain English only."""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.4,
        max_tokens=350,
    )
    return response.choices[0].message.content.strip()


def build_email_body(meetings: list[dict], briefs: list[str]) -> str:
    """Build plain-text email body."""
    today_str = date.today().strftime("%A, %B %-d")
    lines = [
        f"Your meeting briefing for {today_str}",
        f"{len(meetings)} meeting{'s' if len(meetings) != 1 else ''} today",
        "",
        "=" * 60,
    ]

    for meeting, brief in zip(meetings, briefs):
        lines += [
            "",
            f"⏰ {meeting['time']}  —  {meeting['title']}",
            "-" * 40,
            brief,
            "",
            "=" * 60,
        ]

    lines += [
        "",
        "— Your AI Meeting Briefer",
        "  Powered by Ask Patrick (askpatrick.co)",
    ]
    return "\n".join(lines)


def send_email(subject: str, body: str) -> None:
    """Send plain-text email via Gmail SMTP."""
    msg = MIMEMultipart("alternative")
    msg["Subject"] = subject
    msg["From"]    = SMTP_EMAIL
    msg["To"]      = TO_EMAIL
    msg.attach(MIMEText(body, "plain"))

    context = ssl.create_default_context()
    with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
        server.login(SMTP_EMAIL, SMTP_PASSWORD)
        server.sendmail(SMTP_EMAIL, TO_EMAIL, msg.as_string())


def main():
    print("Fetching today's calendar...")
    meetings = fetch_todays_meetings(ICS_URL)

    if not meetings:
        print("No meetings today. Nothing to send.")
        return

    print(f"Found {len(meetings)} meeting(s). Generating briefs...")

    briefs = []
    for m in meetings:
        print(f"  → Briefing: {m['title']} at {m['time']}")
        brief = generate_prep_brief(m)
        briefs.append(brief)

    today_str = date.today().strftime("%A %-d %b")
    subject = f"📋 Meeting Briefing — {today_str} ({len(meetings)} meeting{'s' if len(meetings) != 1 else ''})"
    body = build_email_body(meetings, briefs)

    print("Sending email...")
    send_email(subject, body)
    print("Done. Briefing sent.")


if __name__ == "__main__":
    main()

Sample Output

Here's what a real briefing email looks like for a day with two meetings. The meeting titles and descriptions are the only thing the AI has to work with — this is what it generates:

Two meetings, two tailored briefs, one email. The whole run took 28 seconds and cost $0.02.

Scheduling It (Cron Walkthrough)

The script does nothing until you schedule it. Here's the exact cron setup:

# Open your crontab
crontab -e

# Add this line (runs at 7:00 AM, Monday through Friday):
0 7 * * 1-5 /usr/local/bin/python3 /Users/yourname/scripts/meeting_briefer.py >> /tmp/meeting_briefer.log 2>&1

The >> /tmp/meeting_briefer.log 2>&1 part logs any errors to a file so you can debug if something goes wrong. Check that file if you stop getting emails.

If you want the briefing at a different time — say 6:30 AM — change 0 7 to 30 6. If you want weekends too, change 1-5 to *.

Customizing the Prompt

The four-section brief format (What It's About / What to Prepare / Questions / Outcome) is what works best in practice, but you can change it. Find the prompt variable in generate_prep_brief() and edit the instructions.

Some variations that work well:

• Sales calls: Add "Include one relevant industry trend that might be relevant to mention" to the prompt.
• Internal team meetings: Add "Focus on what decisions need to be made, not background." This cuts the noise.
• 1:1s with your manager: Add "What might my manager bring up that I should be ready to discuss?" to the prep section.
• Technical reviews: Add "Include one question that probes the technical assumptions in the meeting description."

The model is gpt-4o-mini by default. If your meetings are complex or politically sensitive and you want richer briefs, switch to gpt-4o. It costs about 10x more — roughly $0.20–0.30 per day — but the quality difference for nuanced context is real.

The Four Mistakes That Will Break This

Cost Breakdown

Usage	Meetings/Day	Cost Per Run	Monthly Cost
Light schedule	1–2 meetings	~$0.01	~$0.22
Typical schedule	3–5 meetings	~$0.03	~$0.66
Heavy meeting day	6–10 meetings	~$0.06	~$1.32
Upgrade to gpt-4o	3–5 meetings	~$0.25	~$5.50
Typical user (gpt-4o-mini)	—	—	Under $1/mo

At typical usage this costs less per month than a single coffee. The calendar fetch is free. The email sending via Gmail is free.

What to Improve After Your First Week

Once it's running, spend 5 minutes each Friday reviewing the briefs it sent that week. Ask yourself:

• Which brief was most useful? What made it good? (Usually: the meeting had a detailed description.)
• Which brief was too generic? What could you add to those calendar events to help it next time?
• Is there a section you never read? Remove it from the prompt to keep things tight.
• Is there something you always want to know that the brief never covers? Add it to the prompt.

The biggest lever is the quality of your calendar data. Meetings that take 10 seconds to describe well will produce briefs that are genuinely useful. Meetings titled "Chat" with no attendees will produce briefs that are guesses. Both improve over time as you build the habit of annotating your invites.