How I Automated the Worst Part of Product Management

I’m at my desk, wireless microphone clipped to my lapel, dictating instructions to an AI agent.

“Process yesterday’s meeting notes. Route the 1-on-1 with Ashley to her folder, the standup to the team operations folder, and flag anything from the customer escalation call for follow-up.”

I’m not chained to my desk typing. I’m pacing around my office, coffee in hand, talking through what needs to happen. A few years of RSI issues taught me that my hands are a limited resource. Voice input means I save them for the work that actually requires a keyboard.

By the time I sit back down, it’s done. The notes are organized, tagged, and waiting. I didn’t hunch over a screen doing administrative work. I didn’t grind through the tedious part. I just told the system what I needed and moved on.

This is my Tuesday.

Tell me if you’ve been here: It’s Friday afternoon, and you need to write a weekly executive update. You know the information exists in your meeting notes, your Slack threads, your Jira boards, your 1-on-1 docs. But it’s scattered across twenty files and three tools. So you spend 2 hours hunting, copying, synthesizing, and formatting. By the time you hit send, you’re mentally done for the week.

Or this: Quarterly planning kicks off, and you need context from discussions that happened in October. You remember the conversation. You remember disagreeing about the timeline. But where is it? You spend an hour searching, find half of what you need, and reconstruct the rest from memory.

I lived this cycle for years, and as my scope grew, it got worse.

Right now, I manage thirteen projects across three teams at an AI company. Three of those projects are P0 priority and converging toward the same end-of-quarter deadline. One is a major infrastructure migration that touches every downstream API consumer. Another is an observability platform we need to ship before we can launch a third-party integrations bundle. The third is an API key migration that keeps surfacing undocumented compatibility issues that only show up when production traffic hits them. On top of those, I’m running an agent management console, two new model provider integrations, a vibe coding feature for business users heading into early access, and a full-code agent deployment platform for developers entering closed beta with enterprise customers. Plus four smaller workstreams I haven’t mentioned.

Each team has its own standup, its own sprint ceremonies, its own Slack channels, its own Jira board, its own stakeholders asking for updates. I’m in minimum four to six meetings a day. Each one generates a transcript, decisions, action items, and context that I’ll need later. My 1-on-1s with direct reports produce performance observations, coaching notes, and follow-ups. Customer escalation calls surface bugs that connect to projects I haven’t looked at in a week. Architecture review docs drop into my inbox between back-to-back calls.

I tried solving it with better note-taking systems, more disciplined organization, different tools. None of it worked because I was solving the wrong problem.

The Synthesis Problem

Everyone I know has more notes than they can use. We’re drowning in captured information. It turns out the problem is not capturing information, but synthesis of that information.

There is a huge gap between “I have this somewhere” and “I can produce this deliverable now.” Underneath that gap is a cost I didn’t fully appreciate at first. Every hour I spend synthesizing meeting notes and writing status reports is an hour I’m not spending on the work that actually matters:

• Talking to customers and understanding their friction
• Thinking strategically about where the product should go
• Having real conversations with my team, not just processing information about them
• Doing the cognitive heavy lifting that requires focused attention

The tedious parts of knowledge work (the gathering, routing, synthesizing, formatting) were eating the time I needed for the meaningful parts. By default, we spend our best hours on the wrong work.

That’s what I wanted to fix. I wanted to reclaim that time for strategic thinking and human connection.

What I Actually Need to Produce

As a product manager leading multiple teams, my work generates an enormous amount of information:

On a typical day I generate:

• Four to six meeting transcripts (standups for three teams, 1-on-1s, project huddles, sprint ceremonies, customer calls)
• Slack threads where decisions get made at 4pm on a Wednesday and never make it into a document
• Jira tickets being created, updated, blocked, and completed across three separate project boards
• Customer escalation notes that connect to projects I haven’t thought about since last Tuesday
• Architecture review docs that someone dropped in a Google Drive folder between my 10am and 11am meetings

Every week I need to produce:

• A stakeholder update for each team, organized by accomplishments, blockers, learnings, and next steps, covering all thirteen projects
• Sprint planning inputs synthesized from the week’s standups, huddles, and customer feedback
• Performance observations for direct reports pulled from 1-on-1 notes and project contributions

Every quarter I need to produce:

• Planning documents that pull context from three months of discussions, decisions, and scope changes
• PRDs that synthesize a planning 1-pager, Figma design exports, and engineering constraints into requirements with acceptance criteria and a Jira-ready backlog
• OKR assessments tracing project progress back to quarterly goals

That is a lot of synthesis, and every hour I spend on it is an hour I’m not talking to customers, thinking about product direction, or having real conversations with my team.

How I Got Here

My PKM journey spans years, but the AI-augmented system I’m describing only took a few weeks to build once I knew what I needed.

I’ve been using Obsidian since 2021: a personal vault for my own thinking, and a separate one for work. Over the years, I accumulated hundreds of notes. I had ideas, meeting records, project documents, 1-on-1 histories. The information was there. Finding it and synthesizing it was the problem.

Before Obsidian, I bounced between tools that never connected. Google Docs for long-form writing, Google Keep for quick capture, Bear for personal notes. I’d have the same insight twice, months apart, because I couldn’t find where I’d written it the first time.

When I switched to Obsidian, something clicked. Local markdown files meant I owned my data. It felt like an IDE for thinking. Minimal interface, fast, keyboard-driven. I could put the vault in Git and have version history for my notes. The linking and backlinks meant ideas could connect organically instead of being trapped in folders.

I was still doing all the synthesis manually though. I was better organized, but still spending Friday afternoons writing reports by hand.

I started experimenting with voice input after some RSI issues made me protective of my hands. Dictation is 100x faster than typing, and it doesn’t wear out your wrists. I started using Drafts to capture thoughts throughout the day. The goal was to dictate daily observations and have them route to different outputs: daily notes, work logs, newsletter ideas.

It worked, but it was still manual. I’d dictate, then process what I’d captured.

The AI reorganization is where things accelerated. I pointed AI coding agents at both my personal and work vaults and had them do massive reorganizations: analyzing 100+ root-level files, designing folder hierarchies, creating templates with consistent frontmatter, and migrating everything in systematic batches. What would have taken weeks of manual work happened in an afternoon. More importantly, the planning phase (having the AI analyze my actual workflow before deciding where things should go) produced a better structure than I would have designed myself.

The highest impact shift happened when I connected AI agents to the ongoing workflow. Instead of dictating notes for later processing, I could dictate instructions. “Summarize yesterday’s meetings.” “Pull all the customer escalations from this month.” “Generate a draft of the weekly report.”

The voice pipeline became an operating system. The wireless microphone became my interface. The agents became my processing layer.

Now I dictate instructions while pacing my office, and the administrative work handles itself. My hands are saved for work that actually requires typing: deep writing, code review, customer calls, strategic documents.

The System in Brief

The machinery underneath is built on Obsidian, Git, and AI agents with defined workflows. The next post in this series covers the full technical stack, the architecture decisions, and how the pieces connect. The important thing here is what using it actually looks like day to day.

A Real Tuesday

Here’s what a typical day actually looks like.

7:30 AM. Morning standups.

I have three teams and three standups. During the meetings, I’m just present. I’m not taking notes, not filing anything, not thinking about where this information needs to go later.

The transcripts are being recorded by Google Meet, and at 3:30 PM a Writer Agent playbook will pull all of the day’s transcripts from my calendar events at once, summarize each one, and output them as markdown files with structured summaries (key discussion points, decisions, action items, blockers) plus the full transcript attached.

I download those files into my vault inbox, and the end-of-day routing droids take it from there. They match each file against a routing table and file it to the right folder for that team. If the Writer Agent already produced a summary for the same meeting, the Google Meet transcript appends to the existing note instead of creating a duplicate. That merge logic is small but important: without it, you end up with two half-complete records of the same conversation.

The agent that processes my morning notes flags a connection I would have missed. A customer escalation from Monday’s support call mentions the same timeout pattern that showed up in an infrastructure ticket three days ago. Those live in completely different project folders. I would not have connected them manually until it became a bigger problem.

10:00 AM. 1-on-1 with a direct report.

We talk through a technical blocker on the observability platform, some career development goals, and a team dynamics question. Like everything else, the transcript gets picked up by Writer Agent at 3:30 PM, summarized, and downloaded into my vault.

When I run the end-of-day command, the routing droid matches it against the 1-on-1 routing table, identifies the person, and files it to their folder. The technical blocker goes to the project folder with a flag for follow-up. The career development notes append to that person’s running performance document. The team dynamics observation gets tagged for my next skip-level.

I didn’t do any of that routing or categorization. I just downloaded the files and ran the command.

1:00 PM. Product review with leadership.

This is where the system really pays off. Before the meeting, the agent pre-populated a context brief: current status across the three P0 projects, key decisions made this week, open risks, and a draft narrative connecting the infrastructure migration timeline to the observability platform launch. I spent ten minutes reviewing and tweaking the brief instead of forty-five minutes building it from scratch.

In the meeting, someone asks about the relationship between the API key migration and the new model provider integrations. Because the agent had already surfaced the dependency in my context brief, I had the answer ready. That’s the payoff of having a system that does the cross-referencing I can’t do across thirteen projects at once.

4:30 PM. End of day.

This is when the real orchestration kicks in. By now I’ve downloaded the Writer Agent summaries into my vault inbox. I trigger the end-of-day command, which runs five sequential steps. First, it processes any remaining Google Meet transcripts into structured summaries with front matter, then routes them to the right folders. I have 30+ destination folders: 1-on-1s sorted by person, standups sorted by team, sprint ceremonies, incident reviews, customer escalations, partnership meetings, vendor calls.

Second, it sorts any Writer Agent summaries that came in during the day, adding front matter and routing them to the same folder structure. Third (on Wednesdays and Fridays), it tracks Jira ticket transitions for release tracking. Fourth, it pulls Jira activity through three JQL queries: items completed today, items created today, items that changed status. Fifth, and this is the part that saves me the most time, it generates a daily note that synthesizes all of those sources: meeting summaries from both pipelines, git commits with actual file diff analysis (not just commit messages), Jira activity, customer call notes, and cross-team meeting mentions.

The daily note flags three items: the customer escalation pattern that might affect the infrastructure migration timeline, a decision from the product review about the agent builder’s early access criteria, and a staffing risk one of my direct reports surfaced. I review it in five minutes, adjust one bullet, and send the update.

Total time I spent on administrative synthesis today: roughly twenty minutes. Everything else was product work: talking to customers, reviewing designs, making prioritization calls, coaching my team.

The Weekly Report

The weekly report used to eat my Friday mornings. (I’ve written before about weekly reviews as a manual process.) Here’s what it looks like now.

The first draft actually happens on Thursday afternoon, right after the daily flow finishes. I trigger the weekly report skill while the week’s context is still fresh. This isn’t a generic “summarize my week” prompt, but a defined workflow with specific inputs, processing steps, and output format.

The skill pulls the Git log since Monday and analyzes actual file diffs to understand what changed in each note, building a timeline from real content changes rather than summary labels. It reads the meeting transcripts with decisions marked, project status updates, escalation flags, and performance observations, pulling from both the Writer Agent summaries and the Google Meet transcripts that were processed throughout the week. It incorporates the Jira activity that the daily droids captured: items completed, items started, status changes across all thirteen projects. And it cross-references against the previous week’s report to identify what’s new, what progressed, and what stalled.

The output is a detailed report structured by team, with accomplishments, challenges, blockers, learnings, and what’s coming next. This detailed version is for me and my direct reporting chain. I review the Thursday draft, flag anything that looks off, and leave it overnight.

Friday, 11:00 AM. I run the Writer Agent to pull Friday morning’s meeting transcripts, download them, and run the end-of-day skill to process them into the vault. Then I ask the agent to update the weekly report with anything new from Friday. I edit it manually to correct whatever the agent got wrong: reframe a blocker that needs more political context (the agent doesn’t understand organizational dynamics), add a note about a hallway conversation that never made it into a transcript, soften the language on a risk that’s real but not worth escalating yet.

Once the detailed report is ready, I kick off an executive report skill that distills it into a higher-level summary for leadership. Less detail, more narrative, focused on outcomes and decisions rather than individual ticket updates.

I post both versions before I need to leave to pick up my kid from school. The whole process, from Friday’s transcript pull to both reports posted, takes about thirty minutes of my active time. The rest is the agents reading and synthesizing.

The quality is better than what I used to produce manually, because the agent reviewed every single meeting note from the week. I used to skip notes from meetings I considered less important. The agent doesn’t skip anything.

Quarterly Planning

End-of-quarter is where most PMs go into survival mode. You need to produce planning documents, OKR assessments, portfolio reviews, risk analyses. All of it requires context from the last three months, context that lives in dozens of meeting notes, status updates, and decision logs.

Before the system, I’d spend an entire day just gathering context for quarterly planning. Searching through notes, trying to remember when we made a specific decision, reconstructing timelines from memory when I couldn’t find the document.

Now, the agent produces a “state of the portfolio” in minutes. It reads the Git history for the full quarter. It pulls every decision log, every status change, every escalation. It also identifies patterns I wouldn’t have seen: which projects consistently had timeline risks, which ones had scope changes that compounded, where the same blocker showed up across multiple workstreams.

This quarter is a good example. We’re in mid-quarter convergence right now. Three P0 projects all need to land before close. The agent flagged two weeks ago that the infrastructure migration and the API key migration had a shared dependency on the same engineering team’s bandwidth. That’s the kind of cross-portfolio risk that’s easy to miss when you’re heads-down on individual project execution. I caught it early enough to adjust the sequencing.

Performance reviews are the other big win. Instead of spending hours trying to remember six months of 1-on-1 conversations, the agent synthesizes every performance-related note, every project contribution, every piece of feedback. It surfaces patterns: this person consistently delivered ahead of schedule on technical work but struggled with cross-team communication (this is a made-up example!). That kind of synthesis used to take me half a day per person. Now it takes minutes, and it’s more thorough because it doesn’t rely on my selective memory or recency bias.

Where the Human Still Matters

I want to be really clear about what the agents don’t do, because the boundary matters.

Stakeholder conversations. The agent can prepare me with context, but the conversation itself is entirely human work. Reading the room, understanding what someone is really asking versus what they said, navigating competing priorities between leaders all stay with me.

Political reads. When the infrastructure migration is blocked not by a technical constraint but by an organizational one, like a team that’s protective of their system or a leader who hasn’t bought into the direction, no agent is going to navigate that for me. Those things require relationship context, institutional knowledge, and judgment that don’t exist in any document.

Prioritization judgment. The agent can tell me that three projects are at risk or surface the data about each one, but deciding which one matters most right now, which stakeholder to disappoint, or which risk to accept is my job. The agent handles information. I handle judgment.

Customer empathy. I can read a hundred escalation tickets and still not understand what a customer is actually frustrated about until I get on a call with them. The agents help me track the data, but the insight comes from human connection.

Removing the administrative overhead doesn’t make the job easier. You just trade one kind of hard for another. Instead of spending half my time on information synthesis, I spend that time on the hard, ambiguous, deeply human problems that a PM is actually supposed to solve. Those problems are harder than writing a status report. But they’re the ones that matter.

Before and After

The before/after:

Before:

• Friday morning: 45 min to write weekly report
• Quarterly planning: 1 hour searching for October discussions
• Performance reviews: Frantic search for specific 1-on-1 notes
• Sprints: Manual compilation of status from five different sources

After:

• Friday morning: 10 min to review auto-drafted weekly report
• Quarterly planning: Agents surface all relevant discussions + decisions automatically
• Performance reviews: Agents synthesize patterns from all 1-on-1s
• Sprints: Status auto-populates from Jira + notes

The time savings is awesome, but the bigger payoff is what I get to do with the reclaimed time: actual strategy, real conversations with my team, understanding customer friction, thinking deeply about where we’re going.

That was the goal: reclaim that time for strategic thinking and human connection.

What’s Next in This Series

This is Post 1 of a three-part series on AI-powered product management.

Post 2: Inside the System. How the machinery actually works. The technical stack, the architecture decisions, the workflow definitions, and the vault structure that makes all of this possible.

Post 3: Building Your Own AI-Augmented Vault. The design principles and practical steps for building a system like this yourself. What to start with, what to skip, and the mistakes I made along the way.

If you’re a product manager, or any kind of knowledge worker, I’d love to hear if this resonates with you. And if you’re curious about how I ended up doing PM work in the first place, I wrote about what DevRel taught me about product management.