# I Built Claude Skills to Handle Both Sides of My 1:1s

I run 1:1s in both directions every week. Reports come to me, and I go to my own manager. For a long time I prepped for both the same way most people do: a half-remembered sense of what we talked about last time, a scramble through Slack five minutes before the meeting, and a mental note to "follow up on that" that usually didn't survive the rest of the day.

So I built two Claude skills to fix it. One runs the manager side, tracking action items across my reports. The other runs the report side, keeping a running agenda for my own 1:1 with my manager. They're small, they're specific, and I use both of them every day now.

### What the manager-side skill does

`manager-1on1-copilot` scans my calendar for recurring 1:1-shaped events and confirms the list of people with me, rather than making me type out my own team. From there it asks a handful of setup questions: where reminders should land, where the open-items tracker should live, whether I want a recurring block booked for working through action items, and whether I use a notetaker tool. In my own setup that's Google Calendar, Slack for reminders, Google Docs for the tracker, and Granola as the notetaker, but the skill isn't hard-coded to any of those.

Once that's set up, it runs two recurring jobs. Daily, it drafts a note for any 1:1 that just happened, syncs the open-items tracker from my own corrected notes, reminds me a few days out from each upcoming 1:1 of what's still open, and gives me a same-day briefing before I walk in. Weekly, it nudges me ahead of a recurring review block with a rollup of everything still open across the team. None of this is revolutionary. It's just removing the parts of management that are surprisingly easy to forget.

### What the report-side skill does

`report-1on1-prep` is the mirror image, built for my own 1:1 with my manager rather than my reports' 1:1s with me. It finds my recurring 1:1 on the calendar (and confirms it with me, rather than assuming), keeps a running agenda of things I want to raise plus open follow-ups on both sides, and reminds me before each meeting what's actually on it. If you're in a matrixed org with two people you report to in some sense, it'll track a second relationship too.

It also lets you choose the shape of the tracker: one simple list, or split into "things to raise," "I owe them," and "they owe me." I use the split version, and it's exposed something I hadn't really noticed before: how often I was the one sitting on a follow-up. Not because I didn't care about it, but because the week moved on and I'd lost track. Turning "I think we talked about this" into something I can actually see has been one of the more useful side effects of the whole setup.

### Why I built both

The more interesting realization wasn't really about building two separate skills. It was noticing I had the same underlying problem on both sides of the relationship. As a manager, I need to remember what I committed to my reports and what they committed to me. As a report, I need to remember what I committed to my manager and what I need from them. The mechanics are nearly identical; only the direction changes. Once the manager-side skill worked, building the report-side version was mostly a matter of flipping the perspective.

It also changed how I think about 1:1s generally. A good 1:1 isn't really the 30 or 45 minutes of conversation. It's whether the things that come out of that conversation actually get followed through on afterward. That's the part I wanted an agent's help with, not running the meeting, just making sure the meeting didn't evaporate the moment it ended.

### Why neither skill trusts the notetaker

This is the part of the design I'd actually want another engineering manager to notice. AI notetakers are good, but they're not perfect, they can mishear a name, guess wrong about who owns a follow-up, or misattribute a commitment entirely. Both skills treat notetaker output as a first draft only. It gets delivered to me for review, and the actual tracker only ever gets populated from my own corrected notes, once I've read them and fixed whatever's wrong.

That means there's a short lag between a meeting ending and anything showing up on the tracker. That's intentional, not a bug. An unreviewed misattribution, "my manager promised X," or "this report committed to Y", landing straight into the permanent record of that relationship is worse than a one-time transcription slip I'd normally just catch on a re-read. Given everything I've written about trusting agents with more autonomy, this felt like exactly the wrong place to skip the human step.

### What it actually needs to run

Both skills need a calendar connector and a way to deliver reminders. My own setup runs on Google Calendar for the former and Slack for the latter, with Google Docs holding the trackers and Granola handling notetaking. None of those are hard requirements, the skills are written against the category of tool (calendar, chat, docs, notetaker), not a specific vendor, so Outlook, email reminders, or Notion would work the same way. For the recurring jobs to run without me manually kicking them off, both skills use Claude's built-in scheduled-task mechanism, that's currently the only place this works out of the box. The docs connector and notetaker integration are both optional either way; without them, the skill falls back to delivering ready-to-paste text instead of writing directly into a doc.

Recurring-event detection off the calendar is a best-effort heuristic, and both skills confirm what they've found with me before building anything on top of it. Neither one attends the meeting or makes a management decision for me. They automate the prep and the tracking. The conversation is still mine.

### Installing it

Getting either skill running is a five-minute job, not a deployment.

1.  **Get the skill.** Clone the repo:
    
    ```bash
    git clone https://github.com/lemaiyan/pollyskills.git
    ```
    
    Or skip cloning entirely and grab just the packaged skill:
    
    ```bash
    curl -LO https://github.com/lemaiyan/pollyskills/releases/latest/download/manager-1on1-copilot.skill
    # swap in report-1on1-prep.skill for the other one
    ```
    
2.  **Install it.** For Claude Code, the fastest way is straight from the repo, no cloning needed:
    
    ```plaintext
    /plugin marketplace add lemaiyan/pollyskills
    /plugin install manager-1on1-copilot@pollyskills
    ```
    
    Or drop the folder in manually, into a project's `.claude/skills/` directory:
    
    ```bash
    cp -r pollyskills/claude/manager-1on1-copilot .claude/skills/
    ```
    
    For Cowork or Claude.ai, upload the packaged `.skill` file (built with `scripts/package-skill.sh`) through Settings > Skills > Add, if your org allows skill uploads.
    
3.  **Ask Claude naturally to set it up.** There's no special command, something like:
    
    > "help me stay on top of my 1:1s" "help me prep for my 1:1 with my manager"
    
4.  **Confirm the recurring 1:1s it found on your calendar.** It won't build anything until you've verified the list is right.
    
5.  **Answer the setup questions it asks you**: where reminders should go, where the tracker should live, and whether you use a notetaker.
    
6.  Confirm the recurring 1:1s it found on your calendar. It won't build anything until you've verified the list is right.
    

There's no config file to hand-edit first, the whole setup happens in that one conversation.

### Where this goes next

Right now both skills are Claude-specific, they rely on Claude/Cowork's scheduled-task system and skill format, and I don't have a version that runs on cron or a scheduled GitHub Action yet. I'm publishing both on GitHub as-is, Claude-only, with the pieces that would need to change for another platform reasonably contained (the scheduling mechanism, mainly) rather than woven through everything.

If you want to try this with a different assistant entirely, ChatGPT, Gemini, whatever, the actual content of each skill file is just markdown: the setup questions, the logic for how the tracker gets built, the rule about never trusting the notetaker directly. None of that is Claude-specific, and you could paste it into a custom GPT's instructions or a Gemini Gem's system prompt and keep most of the reasoning intact. What won't come with it is the scaffolding around that logic, Claude's connector-based access to your calendar, Slack, and docs, and its built-in scheduled-task mechanism that runs the daily and weekly jobs without you present. You'd be rebuilding those two pieces with whatever equivalent the other platform offers, not dropping in something that already works.

If you do get either skill running on something other than Claude, I'd genuinely like to see it. Open a PR against the repo with what you changed, or just leave a comment here with what worked and what broke, that's exactly the kind of feedback that makes this better for the next person trying the same port.

If you run 1:1s in both directions the way I do, and you're tired of prepping for them from memory, these might save you the same few minutes of scrambling they've saved me. Both skills, along with the install instructions above, are up on GitHub: [github.com/lemaiyan/pollyskills](https://github.com/lemaiyan/pollyskills).

* * *

If any of this resonated, or you're working through something similar, I'd like to hear about it. Reach me at [hello@georgekamunya.com](mailto:hello@georgekamunya.com), or find more of my writing and work at [georgekamunya.com](https://georgekamunya.com/).