I Gave Claude Access to My Calendar —

Now It Manages My 1:1s Better Than I Do

I missed a 1:1 with one of my direct reports. Not because I didn't care — because I genuinely lost track. Here's how I fixed it by building a bridge between Outlook, an MCP server, and Claude.

Curtis (& Claude)

I missed a 1:1 with one of my direct reports. Not because I didn't care — because I genuinely lost track of it. Between back-to-back meetings, a sprint review, and a production incident, a bi-weekly sync just... fell off the radar. It happens. Except when you're managing a team of nine, it can't keep happening.

That's what sent me down a rabbit hole I didn't expect to end where it did.

The Problem Was Simpler Than I Made It

My first instinct was a spreadsheet. Track last 1:1 dates, next scheduled dates, flag gaps. But I'd have to update it manually — which meant it was only as good as the last time I remembered to update it. Which, ironically, was the same problem I was trying to solve.

What I actually wanted was something that could just look at my calendar and tell me when things were slipping.

I'd been using Claude for a lot of my day-to-day work — writing, thinking through problems, drafting comms — so the natural question was: can Claude do this? The answer was no. Not because Claude isn't capable, but because it had no visibility into my calendar at all. It was working blind.

So I needed to build the bridge.

Step One: Getting the Calendar Out of Outlook

This turned out to be the unglamorous part. Outlook doesn't exactly roll out the red carpet for external integrations. What it does support is publishing an ICS feed — a URL that exposes your calendar in a standardized format that anything can read.

Getting there required digging into Outlook settings to publish the calendar, scoping which calendars to expose, and landing on a stable URL I could actually use. It took longer than it should have, mostly because the documentation is scattered and the UI has clearly been touched by a dozen different product teams over the years.

The flow looked roughly like this:

1. Open Outlook settings → Calendar → Shared calendars
2. Under Publish a calendar, select your calendar and set permissions to "Can view all details"
3. Click Publish — Outlook generates an ICS URL
4. Copy that URL. That's your feed.

Once I had a working ICS feed, I had a live, queryable window into my schedule. The hard part was done.

Step Two: Wrapping It in an MCP Server

The Model Context Protocol (MCP) is how you give Claude real tools. Instead of pasting calendar data into a chat window, you build a small server that exposes functions Claude can call — and Claude decides when and how to use them, autonomously.

I built a calendar plugin with a handful of capabilities:

• Fetch my schedule for a given date range
• Search meetings by title or keyword
• Find 1:1s by person's name — scanning forward and backward across the calendar and returning every matching meeting

That last function was the key piece. Given a name, it looks for common 1:1 title patterns — Name <> You, You / Name, Name 1:1 — and returns everything it finds in the specified window.

The MCP server gets wired into Claude via ~/.claude/mcp.json. Once it's registered, Claude can call the calendar tools the same way it calls any other tool — no copy-paste, no manual context, just a function call that returns structured data.

{
  "mcpServers": {
    "calendar": {
      "command": "node",
      "args": ["/path/to/calendar-mcp/index.js"],
      "env": {
        "ICS_URL": "https://outlook.live.com/owa/calendar/..."
      }
    }
  }
}

The plugin fetches the ICS feed, parses it, and exposes clean tool functions. Claude doesn't know or care that it's backed by an Outlook ICS URL. It just sees a tool called find_one_on_ones that takes a name and returns meetings. I've published the full plugin on GitHub if you want to use it as a starting point.

What It Actually Looks Like Now

Now I run a scheduled health check across all nine of my direct reports in one shot. Claude queries past and upcoming 1:1s for each person, calculates days since the last meeting, checks how many are on the books ahead, and builds a prioritized summary.

This is actual output from this morning's run:

None of that required me to open my calendar. I got a prioritized action list — one URGENT flag, four LOW warnings, and specific recommendations for each — before my first coffee.

The flagging logic is simple but effective:

• URGENT — no 1:1 in 21+ days and nothing scheduled
• ACTION NEEDED — nothing scheduled, even if recent
• LOW — only one future 1:1 on the books (the series may be running out)
• OK — two or more future 1:1s scheduled

The "LOW" flag turned out to be unexpectedly useful. Recurring calendar series in Outlook often have an end date that quietly passes — and you don't notice until the meeting just stops showing up. Catching one-instance series before that happens is exactly the kind of thing I'd previously miss entirely.

The Bigger Shift

The point isn't that I automated a spreadsheet. The point is that Claude went from being a thinking tool to being a management tool. It's not just helping me write — it's helping me notice things I'd miss, flag risks before they become problems, and stay ahead of the parts of the job that are easy to deprioritize when everything feels urgent.

Giving Claude access to my calendar was a small technical lift. The change in how I manage my team has been anything but small.

The MCP model is what makes this work. It's not about feeding Claude data — it's about giving Claude tools it can use autonomously, in context, as part of a larger workflow. The calendar plugin is one tool. It composes with everything else Claude can already do.

I've started thinking about what else fits this pattern: things I check manually on a recurring basis, where the data exists somewhere structured, and where I mostly want to be told when something's off. Deployment health. PR review queue depth. Sprint velocity trends. The calendar was just the first domino.

If You Want to Build This

The rough sequence:

1. Publish your ICS feed from Outlook. Settings → Calendar → Shared calendars → Publish. Copy the ICS URL.
2. Grab the MCP server — I've open-sourced the plugin on GitHub. It fetches and parses the ICS feed and exposes a find_one_on_ones(name) function ready to go.
3. Register it in ~/.claude/mcp.json with your ICS URL as an environment variable.
4. Write a scheduled task in Claude Code that calls the tool for each person, builds the summary, and flags issues.

The ICS parsing step is the most involved, but there are solid libraries for it in most languages. The MCP server itself is a thin wrapper — the protocol handles the rest.

You don't need to be a calendar API expert. I'm not. I just wanted Claude to stop working blind, and it turns out the path from "Outlook ICS URL" to "Claude understands my schedule" is shorter than it looks.

If you're building MCP integrations or using Claude Code for management workflows, I'd love to compare notes. The patterns are still forming and there's a lot of unexplored territory — especially at the intersection of AI tooling and the quieter parts of the engineering manager job.