AI Copilot with MCP / AI Bites 03

Leverage MCP Servers to create your copilot (fetch context, improve AI results, and take actions). Start with 2 simple tasks: create tickets and communicate progress.

Hey everyone,

Thank you so much for your likes, shares, and votes on the previous edition of AI Bites 🔥. It seems you’ve enjoyed the GPT-5 “Prompter” project, and the Ticket writer prompt.

In today’s edition, I deep dive into these most voted topics:

• Backlog Autopilot: leverage AI to manage your backlog (MCP)

• Communicate Progress: use AI to write progress reports (MCP)

Prompts are getting long, so I’m now storing them in a Notion database. Tap the buttons to access the full prompt (for free).

Enjoy!

---

Before we dive in, Claire Vo released a video with Dennis Yang where he presents his Cursor workflow (99% similar to the one I’ll describe below). 📺 If you prefer a video version, be sure to watch it!

What is an MCP Server?

I use several MCP servers in my daily life. Here’s a quick definition:

Model Context Protocol is a standard for connecting AI applications to external systems. Basically, it’s an API designed for LLM. Meaning it can easily discover available capabilities, use them, answer questions, and take actions.

• 2 types of servers exist:

  • public ones (usually there is a public URL you reference)

  • local ones (which can use some commands or executables, on your computer) which are only available from a desktop app.

• Most modern tools like Notion, Linear, Figma or Amplitude, have been rushing to release their public “MCP Server” usable in desktop and web apps.

• You can install them into AI apps like Claude, Cursor or Agents like Claude Code / Codex. Note: ChatGPT MCP support is still pretty nascent (and limited to the “developer mode”).

Which AI should you use as your copilot?

I’ve been using Cursor for a few years (to develop), but it’s now my favorite way to edit files and create projects too (non-developer tasks).

Now I can:

• Create a simple folder on my computer with a few knowledge files that are completely “portable” (topic to be covered in another edition).

• Add a few cursor rules (= shortcuts) to automate my usual prompts like writing tickets, scoping down or writing a progress report.

• Plug MCP servers to be efficient (Linear/Notion for backlog access, Granola for meeting transcripts access, Figma for design access, Amplitude for data access…).

• Chat “with the folder” to brainstorm, analyze data, work on PRD, and more.

• Create files with AI, but more importantly take over, and edit them manually in the editor.

My usual Cursor setup

If you’re curious about Cursor, but you’re not sure where to start: this article on the modern AI workspace should help you.

Obviously, it’s not going to be everyone’s cup of tea, so here’s a comparison of the main tools you can use to leverage MCP power, and my use case for each 👇

Click here for html version or tap on the image to read the table

Note: This table is inspired by Teresa Torres’ article on Claude Code. Highly recommended read.

🛫 Backlog Autopilot

I’m collaborating with teams that host their tickets in Notion as well as Linear. Fortunately, both have MCP Servers that I can use to “pilot” my backlog. Note: I’ll share examples written for Linear (but it works the same for other MCPs).

Currently, I have 2 methods to create tickets in the backlog:

• I create tickets directly in the backlog with a few bullet points (= some notes for myself). Then when I need to really write the content, I’ll ask the AI to read the ticket, collaborate, and update it in the backlog.

• I write a PRD document for larger initiatives, talk with AI to find the best way to scope independent tickets, ask clarifying questions for each, then create the tickets in the backlog. 💬 Let me know if you’d like me to share this prompt next.

Improving a specific ticket

To write this prompt I used the following method:

1. Started a new chat explaining my goal: “create a new command that will read a ticket content through (MCP step), interview me, then suggest a ticket, once I approve, it should update in the backlog (MCP step)”

2. Pasted my “writing guidelines”, basically the instructions I shared in AI Bites #2.

3. Iterated on the level of details, and rules to make sure it works 99% of the time.

To use this prompt I just:

1. Open Cursor, and enter: “/ticket-refine” along with the url of the ticket. That’s it.

2. When additional information could be useful

   1. I use Cursor mentions, to attach specific knowledge files in the folder. I add “@filename”, and the ticket refiner prompt will read my PRD or some user research extracts.

   2. I ask AI to use specific MCP servers like Amplitude/Posthog to extract data, Figma to analyze design, etc.

# ticket-refine

## Workflow

### 1. Fetch Ticket from Linear

**Input**: User provides either a Linear ticket URL (e.g., `https://linear.app/acme-corp/issue/PROJ-456`) or ticket ID (e.g., `PROJ-456` or UUID).

**Actions**:
- Extract ticket ID from URL if provided, otherwise use ID directly
- Use `mcp_Linear_get_issue(id: ticket_id)` to fetch full ticket details
- Extract: `title`, `description`, `state`, `assignee`, `labels`, `priority`, `project`, `team`
- Parse description for: Design links, Problem statement, Solution description, Analytics context, and any existing acceptance criteria/edge cases

### 2. Interview Phase - Ask Clarifying Questions

Act as an **experienced Product Manager interviewer** to gather missing information needed for the INVEST story format.

**Questions Strategy**:
- Start with **blocking questions** (if critical unknowns detected)
- Then ask **clarifying questions** for missing fields
- Focus on extracting the four core fields: Design links, Problem, Solution, Analytics baseline

[too long...] Tap the button to access the whole prompt

Turning a PRD into independent tickets

This prompt follows the process: 1. Reads PRD (Linear document or local file) → 2. Scopes first version → 3. Suggests independent tickets → 4. Lets me review → 5. Creates tickets in Linear.

💬 Comment or reply to this edition if you would like me to share this prompt.

📣 Communicate Progress

We spend so much time communicating about progress, challenges, and plans. Then we reframe the same message for different audiences.

Fortunately for us, AI is quite efficient at both writing and reframing. Note: I created these prompts after watching the Dennis Yang video mentioned earlier, what an amazing idea!

For educational purposes, I’m sharing 2 versions of this prompt in order to demonstrate my thinking process.

Backlog Progress

1. I started by reviewing a few examples of past progress reports I wrote. Usually it has sections like: Exec Sum, In Progress, Recently Done, Needs Attention.

2. I connected Cursor with Linear MCP (to access the backlog info)

3. I created a Cursor Rule (= a shortcut) called progress-report that accesses Linear, reads tickets, then writes a progress report. The anonymized prompt 👇

   Please check what’s in our current backlog in Linear MCP and let me know what is in progress, what has been done recently (last 7d), and if there was any progress. If some issues needs design, give me an overview. If comments are unanswered in some issues, let me know. 
   
   Make sure to not talk about cancelled or deleted issues. 
   
   Format the report like this:
   ```markdown
   ## Summary
   - **Progress**: 
   - **Design bottleneck**:
   - **Pending (comments, decisions, blockers)**:
   - **Recommended next steps**: 
   
   ## 📊 In Progress (4 issues)
   - ID - Issue Name 1 (Assignee)
     - Description of the issue
     - Highlights (if any)
     - Remaining work (if any)
   
   [too long...] Tap on the button to access the prompt

Project Progress (Backlog & Meetings)

I realized that a lot of the key informations live outside Linear tickets. But I’m lucky: my colleagues are okay with me using a meeting recorder, and I work in remote situations (so close to 100% of meetings are recorded).

1. I connected Granola MCP to access my meeting transcripts.

2. I improved the previous progress report instructions to follow this precise process: 1. Gather context (from Linear & Granola) → 2. Scan for data → 3. Extract facts → 4. Filter → 5. Write report.

3. I used the prompt for a few days, and realized the MCP calls could go faster if they were described in details. I asked my AI chat to add these additional details. My exhaustive anonymized prompt 👇

   ## Workflow
   
   ### 1. Gather Time Context
   - Default time window: **last 7 days** (one sprint = 1 week)
   - If user specifies different window, use that
   - Apply recency bias: weight most recent items highest
   
   ### 2. Scan Data Sources
   
   #### Linear MCP
   
   **Team**: “Your Team Name” (single team, do not use cycles)
   
   **Step 1: Get Team & Verify States**
   - Get team details: `mcp_Linear_get_team(query: “Your Team Name”)` to get team ID
   - Optional: Get available states: `mcp_Linear_list_issue_statuses(team: “Your Team Name”)` to verify exact state names
   
   **Step 2: List Issues for Team**
   - List all issues for “Your Team Name” team: `mcp_Linear_list_issues(team: “Your Team Name”, includeArchived: false)`
   - **Important**: After getting issues, filter out:
     - Issues with state “Cancelled” or “Canceled” (check `state.name`)
     - Issues with label “Duplicate” (check `labels` array for “Duplicate” label)
     - Issues with title containing “duplicate” (case-insensitive)
     - Archived issues (already filtered by `includeArchived: false`, but double-check)
   
   [too long...] Tap on the button to access the whole prompt

—

Thank you for reading this far. I hope you’ll find these new prompts useful. It took me a long time to write.
Until next time!

Olivier

---

Share → Please help me promote this newsletter by sharing it with colleagues (tap the refer button) or consider liking it (tap on the 💙, it helps me a lot)!

About → Productverse is curated by Olivier Courtois (15y+ in product, Fractional CPO, coach & advisor). Each issue features handpicked links to help you become a better product maker.