How Dennis Yang Automates Product Management and Prototypes AI with Cursor

This week’s episode was a bit of a reality check for me. I thought I had a pretty good handle on being an AI-powered PM, but after sitting down with Dennis Yang, Principal Product Manager for Generative AI at Chime, I realized I have a lot to learn. Dennis has created workflows that are way beyond anything I've seen before, turning a code editor into the central nervous system for his product management work.

He has completely rewired his product workflow around Cursor, an AI-powered IDE that's normally just for software engineers. The fascinating part is, he’s not using it to write code. He’s using it to write PRDs, manage documentation, interact with tools like Jira and Confluence, and even prototype new AI products. His whole approach is built on interoperability, and it really shows where things are headed—a future where the lines between documentation, project management, and code start to blur.

In our conversation, Dennis walks us through two of his most impressive workflows. First, he shows his end-to-end system for the entire product management lifecycle—from creating a PRD in Markdown to automatically generating status reports. Second, he shows us how he prototypes brand-new AI agents using what he calls a "Super MVP" approach, all within Cursor and without writing a single line of code. This one is a must-listen for any product manager, builder, or anyone curious about using IDEs for non-technical work.

Workflow 1: The End-to-End AI-Powered Product Management Lifecycle

As product managers, we spend so much of our time translating the same information for different audiences. We take customer notes, write a PRD, summarize it for engineers, create bullet points for executives, and by the time we get to creating Jira tickets, we're exhausted and they end up being pretty thin. Dennis’s first workflow is designed to fix this fatigue by creating a single, integrated system inside Cursor.

Step 1: Setting Up Your Cursor Environment for Writing

Before he starts, Dennis optimizes Cursor for writing, not coding. The main idea is to use Markdown as the universal format. Since raw Markdown can be tough to look at, he uses an extension to make it more readable.

1. Install a Markdown Previewer: Dennis recommends the Markdown Preview Enhanced extension. This automatically shows a clean, readable preview of your Markdown file in a separate pane whenever you click on it.
2. Organize with a File System: Unlike a Google Doc, Cursor gives you a direct view of your file system. Dennis creates a dedicated directory for all his product documents, treating them like source code.
3. Embrace Source Control: He uses Git to version control everything. This applies concepts like change tracking and commit history—which are usually just for code—to product documentation. It’s a really interesting idea: what if the PRD lived right next to the code it describes in the same repository?

"I'm wondering is that if I think I wanna start to see if the artifacts are actually sitting inside the repo into which the code is being developed, adjacency actually encourages the engineers and the ai. Coding assistant to continually have access to this."

Step 2: Creating and Publishing PRDs with MCPs

With his environment ready, Dennis writes his PRDs in Markdown directly in Cursor. But a PRD isn't much use if it's stuck on his local machine. He uses Model Context Protocols (MCPs) to connect Cursor to other important company tools like Confluence and Notion.

1. Write the PRD: He drafts the entire PRD in a .md file in his project directory.
2. Activate the MCPs: In the Cursor settings, he makes sure his MCPs for Confluence, Notion, and Jira are enabled and showing a green light.
3. Publish with a Simple Prompt: He then uses a natural language prompt in the chat pane to publish the document.

Let's publish it into Confluence. Don't overwrite the other one we already pushed, make a copy please. And I'm demoing this capability!

The AI does the rest. It uses the correct MCP tool, authenticates, and creates a new page in Confluence with the perfectly formatted content from his Markdown file. It even returns the URL of the new page and adds it back to his original document in Cursor, which I thought was a nice touch.

Step 3: Closing the Feedback Loop with AI-Assisted Responses

This next part is where I was really blown away. After publishing the PRD, Dennis’s colleagues start leaving comments in Confluence. Instead of manually reading and replying to each one, he uses AI to handle the feedback.

1. Query for Comments: He prompts the AI to read the Confluence page and pull in all the latest comments.

Looks like people have been commenting on the PRD. Please go through the comment one by one and let's see how we'll respond.

1. Categorize and Suggest Responses: The AI reads the comments, sorts them by priority (High, Medium, Clarifications), and drafts a suggested response for each one.
2. Human-in-the-Loop Review: Dennis then reviews the AI's suggestions. He has the final say, making sure the responses are accurate and sound like him. He just has to say "yep, that one's okay" to approve a response.
3. Publish Responses: The MCP, authenticated as Dennis, posts the approved responses back to the Confluence page. To his colleagues, it just looks like Dennis is thoughtfully and quickly replying to every single comment.

Step 4: From PRD to Action: Automating Jira Ticket Creation

Once the PRD is finalized and the feedback is incorporated, it's time to break the work down into tickets for the engineering team. This is another one of those tedious tasks that Dennis automates.

1. Prompt to Create an Epic: He tells the AI to read the final PRD and create a new epic in a specific Jira project.

Read the PRD and create an epic in the TIA project.

1. Generate Detailed Story Tickets: Next, he asks it to create the individual story tickets and link them to the parent epic. Because the AI has all the context from the PRD, the tickets it creates are detailed and well-structured—much better than what a PM in a hurry might write.

Let's create story tickets that are all associated with the parent Epic for this feature.

The results are pretty amazing. The tickets have detailed descriptions, user stories in Gherkin format, and clear acceptance criteria. This saves Dennis a ton of time and gives the engineering team real clarity, avoiding that classic situation where a ticket description just says "Link to PRD."

Step 5: Automating Weekly Status Reports

The final piece of the lifecycle is reporting on progress. Instead of manually chasing down updates and putting a report together, Dennis just queries Jira directly from Cursor.

Let's write a status report and describe everything that has happened since 9/24 for this epic I'll give it this epic here.

The AI uses the Jira MCP to run a JQL query, checks the status changes of all the related tickets (e.g., from In Progress to Done), reads any comments, and puts together a detailed status report. Dennis has even saved his preferred report format as a Cursor Rule, so he gets a consistent, high-quality update every week from a single prompt. This not only saves him time but also encourages engineers to keep their tickets updated, because they know the information is actually being used.

Workflow 2: Prototyping a "Super MVP" AI Agent in Cursor

Dennis's second workflow is all about going from an idea for a new AI product to a working prototype without writing any traditional code. He shows how it works by building a personal "Morning Briefing" agent.

Step 1: The Simple Prototype in ChatGPT

Like a lot of us, Dennis started out by prototyping in a consumer tool. He opened a chat in ChatGPT and for months, his only prompt each morning was:

Write me a morning briefing based on what you know about me.

By using this simple, repetitive prompt, he was able to get a feel for the model's capabilities and its limitations, especially around memory and context. It’s a good lesson for anyone building with AI: using these tools daily helps you develop an intuition for their strengths and weaknesses.

Step 2: Building the "Super MVP" in Cursor

When he was ready for a more robust and customized version, he didn't start writing Python scripts. He used Cursor as a no-code environment for AI prototyping. He calls this the "Super MVP"—a super minimal viable product where the instructions themselves are the application.

1. Define the Product: He started with a PRD and a Technical Design Document (TDD) for his Morning Briefing agent, which he had Cursor help him write.
2. Write the Agent Instructions: The heart of the Super MVP is a set of step-by-step instructions written in plain English that tell Cursor how to behave as the agent. These instructions are just stored in a Markdown file.

The instructions lay out a clear plan:

• Load configuration from a profile file.
• Use the news_search MCP tool to search for articles on specific topics.
• Process and summarize the content.
• Generate a final report in a specific format.

1. Execute the Agent: To run his prototype, he simply references the instruction file in the chat.

@super_mvp_agent_instructions run today's briefing.

This is the really clever part. Cursor itself becomes the engine that runs the agent. It reads the instructions, calls the right MCPs (like the News API), chains the steps together, and performs the task. He can easily swap out the underlying model (Claude, GPT-4, Gemini) to compare how they perform without changing any code. This is an incredibly fast and effective way for a non-technical PM to prototype, test, and refine the logic of an AI product before handing it off to engineering.

Conclusion: The Future is Interoperable

What Dennis is doing really feels like a look at where knowledge work is going. He’s shown that tools traditionally built for developers, like Cursor, can become a central hub for anyone when you add a natural language AI on top. It all comes down to interoperability—connecting your AI to the systems where work actually happens, like Jira, Confluence, and Notion.

By treating documentation like code with Git and automating the repetitive, low-value parts of product management, he frees himself up to focus on strategy and bigger-picture thinking. And his "Super MVP" method for prototyping is a fantastic way for anyone to start building and testing complex AI agents without needing to be an engineer. I walked away from this conversation with a dozen new ideas, and I hope you do too. I'd encourage you to try connecting your favorite AI to your favorite tools—you might be surprised by what you can build.

Thanks to Our Sponsors!

Thank you to the sponsors of How I AI for their support:

• Zapier: The most connected AI orchestration platform
• Brex: The intelligent finance platform built for founders

Episode Links

• Watch on YouTube
• Listen on Spotify
• Listen on Apple Podcasts