How I AIHow this PM uses AI for PRDs, JIRA tickets, and replying to coworkers | Dennis Yang (Chime)
CHAPTERS
- 0:00 – 3:00
Why Cursor works for PM writing: models, files, rules, and tool interoperability (MCP)
Dennis explains why he uses Cursor as his primary AI interface even when not coding. The core reasons are multi-model access, a local file system for persistent artifacts, Cursor Rules for repeatable workflows, and MCP-based integrations with PM tools.
- •Cursor supports multiple LLMs (e.g., Claude, GPT, DeepSeek) for quick model switching
- •Local file system enables durable artifacts (PRDs, specs) rather than transient chat output
- •Cursor Rules encode personal/team conventions and recurring instructions
- •MCP connectors let Cursor interact with Jira, Notion, Confluence, Figma, GitHub, etc.
- •Cursor becomes a “hub” UI for day-to-day product work, not just coding
- 3:00 – 4:53
Cursor as a desktop “work cockpit”: panes, speed, and monitoring MCP health
They walk through the Cursor layout and why the desktop experience feels fast and ergonomic. Dennis highlights how he monitors tool connectivity (green/red MCP status) and optimizes screen real estate for chat, artifacts, and files.
- •Three-pane mental model: file tree (left), artifact/editor (center), chat (right)
- •Desktop responsiveness makes iterative AI workflows feel “zippy” compared to web tools
- •Bottom pane used as a settings/tools monitor (instead of terminal) for PM workflows
- •Toggling MCPs on/off is a practical troubleshooting pattern when things fail
- •Large screens help: simultaneously viewing chat, doc, file system, and MCP status
- 4:53 – 9:35
Non-coder setup: Markdown-first writing and live preview in Cursor
Dennis shares a practical setup for PMs writing in Markdown inside an IDE. He demonstrates enabling Markdown preview and using an extension so PRDs are readable without staring at raw Markdown syntax.
- •LLMs work particularly well with Markdown structure and headings
- •Markdown Preview Enhanced extension enables automatic preview rendering
- •Settings workflow: Command+, to find Markdown preview options
- •Preview reduces friction for long-form PRDs and tables
- •Positions Cursor as a full-time PRD editor, not just a chat tool
- 9:35 – 10:33
PRD workflow in a multi-player org: draft in Cursor, publish to Confluence/Notion for comments
Dennis describes Chime’s PRD feedback ritual: write early drafts, share broadly, collect comments, and iterate. Since Git isn’t ideal for company-wide commenting, he publishes PRDs to Confluence and/or Notion via MCP.
- •PRDs start in Cursor (Markdown) but collaboration happens in Confluence/Notion
- •Git is used for source control, but not as the commenting layer for most stakeholders
- •Publishing to both Notion and Confluence accommodates different team preferences
- •MCP enables pushing the same artifact into collaboration tools quickly
- •Goal: reduce time spent on comms while improving the quality of circulated status/PRDs
- 10:33 – 11:38
Docs + Git + code adjacency: the ‘source of truth’ debate and interoperability requirements
They discuss the shift of product artifacts into repos alongside code and the benefits for engineers and AI coding assistants. Dennis argues interoperability will be decisive: he avoids systems that lock content away from other tools.
- •Artifacts traditionally live outside code; Cursor+Git brings them into repo-like workflows
- •Keeping PRDs adjacent to code can improve access for engineers and coding agents
- •Idea: Cursor Rules that nudge updates to PRDs as implementation learns evolve
- •Interoperability becomes a selection criterion for tools (avoid “content lock-in”)
- •Markdown files + source control become a surprisingly strong competitor to SaaS UIs
- 11:38 – 17:00
Publishing via MCP: how the ‘push to Confluence’ interaction works (and fails live)
Dennis demonstrates the natural-language workflow to publish a PRD into Confluence, including creating a copy and inserting the published URL back into the doc. They also show the reality of MCP instability and how people troubleshoot it.
- •Natural prompt: ‘Publish this PRD into Confluence’ + constraints (don’t overwrite, make copy)
- •Tool visibility: inspecting enabled tools helps form a mental model of capabilities
- •Naming ambiguity across tools can confuse agents (e.g., many things called ‘project’)
- •Practical mitigation: toggle tools on/off to narrow context and reduce misfires
- •Round-trip workflow: publish → get URL → update local artifact with canonical link
- 17:00 – 21:37
Closing the loop on collaboration: AI reads PRD comments and drafts replies as Dennis
Dennis shows a more advanced workflow: Cursor reads Confluence comments, groups them by priority/type, drafts suggested responses, and posts them under his identity after review. The key is keeping a human in the approval loop while offloading the typing and triage.
- •AI pulls comments directly from Confluence and organizes them (high/medium/clarifications)
- •Drafts response suggestions for each comment; Dennis approves/edits before posting
- •Authenticated MCP actions post replies as the PM account (appears as Dennis)
- •Human-in-the-loop is positioned where it adds value: judgment, not rote work
- •Result: faster iteration cycles on PRDs without sacrificing responsiveness
- 21:37 – 25:51
From PRD to execution: generating Jira epics and well-formed story tickets from the doc
Next, Dennis tickets the work into Jira by having Cursor read the PRD and create an epic plus associated stories. He notes that AI-generated tickets often include richer details than a busy PM would normally write (acceptance criteria, structure, clarity).
- •Prompt: read PRD → create epic in a specified Jira project
- •Generate story tickets linked to the parent epic (avoid orphaned tickets)
- •Cursor Rules encode Jira hygiene (e.g., always associate stories with epic)
- •AI outputs higher-quality tickets: descriptions, Gherkin, acceptance criteria
- •Reduces PM toil translating the same info across formats and audiences
- 25:51 – 30:23
Status reporting automation: JQL-driven weekly updates from Jira activity
Dennis explains how he generates status reports by having Cursor query Jira (via JQL) for activity since a date or within an epic. Over time, he built a longer Cursor Rule to standardize the weekly report format and improve consistency.
- •Prompt: ‘Write a status report… for this epic since [date]’
- •Agent uses Jira as source of truth; even minimal ticket titles can be enough signal
- •Interactive iteration first, then codify as a reusable Cursor Rule template
- •Secondary effect: engineers add more context to Jira knowing it feeds reporting
- •Outcome: less time writing status, better quality updates for leadership and org-wide sharing
- 30:23 – 35:03
Asynchronous communication & culture: reducing pings and even automating gratitude
They connect the workflow to hybrid/remote collaboration: fewer synchronous interruptions when updates live in structured systems. They also riff on using AI to reinforce team culture (e.g., thank-you comments) while acknowledging it’s powered by LLMs.
- •Status queries replace repeated ‘what’s the update?’ pings to engineers/EMs
- •Structured sources (Jira comments/transcripts) become AI-queryable context
- •Less context switching and fewer meetings for routine updates
- •Idea: automate positive reinforcement on completed tickets (thanks/acknowledgment)
- •Culture and communication become partly ‘agent-assisted’ in modern teams
- 35:03 – 40:04
Personal workflow: ChatGPT ‘morning briefing’ as a daily AI habit and model barometer
Dennis shares a daily routine: asking ChatGPT for a personalized morning briefing in a long-running project. He observes performance drift over time (memory/context issues) and uses the habit to build intuition about model behavior changes.
- •Simple daily prompt: ‘morning briefing’ in a ChatGPT Project
- •ChatGPT memory can produce relevant summaries, but can degrade or lose focus
- •Daily use helps detect when models get better/worse and why UX fails
- •A repeated personal task builds practical intuition for AI product design
- •Lesson: don’t rely solely on implicit memory—add explicit context when needed
- 40:04 – 46:37
Prototyping AI products with ‘zero code’: PRD → TDD → Super-MVP agent instructions in Cursor
Dennis demonstrates a lightweight product prototyping loop inside Cursor. He turns a PRD into a technical design, then into execution instructions that call MCP tools (news search), summarize results, and produce a report—without writing application code.
- •Prototype first in ChatGPT, then formalize inside Cursor for repeatable execution
- •Cursor writes a TDD (technical approach) from the PRD to clarify steps/tools
- •‘Super MVP agent instructions’ act like prompt-based operational code
- •Agent runs: load config → query news MCP → summarize → format briefing
- •Benefits: tool calling, model switching, and chaining happen without building an app
- 46:37 – 50:07
Lightning round: transparency about AI replies, Cursor quickstart, and calm prompting style
Dennis answers rapid-fire questions about whether coworkers know he uses AI, how PMs should start with Cursor, and what he does when tools fail. His advice: start simple, be polite, and restart threads when things go sideways.
- •Colleagues are aware he’s ‘fully AI-enabled’ (and he’s back in-office)
- •Quickstart: open Cursor, create a fresh directory for product artifacts, start chatting
- •Troubleshooting: stay calm, use ‘please,’ restart the thread if needed
- •Pragmatic handling of flaky MCPs: toggle, verify green status, try again
- •Mindset: iterative learning and resetting is part of working with today’s AI tooling
