An autonomous Synthetic Product Brain Trust inside your IDE (Cursor/Claude). Gain the leverage to escape the feature factory, elevate your product sense, and focus on building the right thing with exceptional taste.
For the last decade, Product Management lost its way. PMs were meant to be product builders, deeply connected to user pain and product craft. Instead, the industry turned them into backlog administrators, alignment-bureaucrats, and meeting-facilitators.
The Last PM is an open-source AI ecosystem designed to restore the craft of product building. It is not just a 'PRD generator'— it is your Synthetic Product Brain Trust. Think of it as an autonomous board of product titans, mathematically designed to tear apart your roadmap and expose fatal flaws before engineering writes a line of code. It automates the administrative tax of product strategy, data synthesis, and stakeholder alignment. By outsourcing the bureaucracy to the OS, human builders are finally free to focus on what AI cannot do: product sense, user empathy, and shipping with incredible taste.
| The Feature Factory PM | The High-Craft Builder (Using Last PM) |
|---|---|
| Spends days wordsmithing alignment docs. | Synthesizes complex strategy into sharp, Amazon-style 6-pagers in seconds. |
| Ships features to appease stakeholders. | Uses the AI to mathematically stress-test roadmaps against actual business leverage (The "Great Taste" Matrix). |
| Drowns in unstructured customer feedback. | Auto-extracts core user friction and monetization opportunities from raw transcripts. |
| Manages the Jira board. | Lives in the trenches, iterating prototypes, and obsessing |
- "AI hallucinates and lies to me." Generic chatbots lie. The LastPM does not use open-ended chat. It is a deterministic state machine. It uses the KERNEL framework to map your data against mathematical scoring matrices (0-10 on Defensibility, Distribution, etc.). It doesn't guess; it calculates based on your hard inputs.
- "I need to run an AI 1,000 times as a thought partner to get anything good." That is because you are starting from a blank prompt. The LastPM uses 50+ battle-tested, highly constrained playbooks (LNO, JTBD, Tiering Strategy). You aren't teaching the AI how to think; the OS is forcing you to run your ideas through the same mental models used by the magnificent seven.
- "I only trust what I see. I won't let an AI write my strategy." Neither would we. The LastPM is designed with Mandatory Human Checkpoints. If you pitch an idea with a fatal flaw (e.g., terrible monetization), the OS hits the brakes. It will not write the PRD. It flags the risk and forces you to pivot the strategy first. It is an exoskeleton for your product sense, not a replacement for your brain.
Great product leaders don't start from a blank page. They rely on mental models.
You simply talk to The Last PM right inside your IDE. You state your strategic blocker, and the Orchestrator diagnoses the problem and silently summons the perfect mental model in the background. It commands a directory of expert agents, modeled after the methodologies of the industry's top product minds:
- Strategic Leverage & Prioritization: Stop guessing. The system runs the LNO framework (Leverage, Neutral, Overhead) to ruthlessly cut the roadmap down to what actually moves the needle.
- Continuous Discovery & Product Sense: Feed the OS raw user interviews, and it maps the precise psychological friction preventing users from activating or retaining.
- Go-To-Market & Monetization: Design your pricing model, SaaS tiers, and packaging logic before engineering writes a single line of code.
- Positioning & Context: When the market doesn't "get" your product, the system reframes your narrative so your unique value proposition becomes undeniably obvious.
- Launch Risk Pre-Mortems: When facing launch anxiety, the OS hunts down the fatal execution risks (the Tigers and Elephants) before they break your app.
You supply the product sense. The AI OS provides the leverage. You build the right thing.
The Last PM is not a traditional software app you install. It is a file system and a set of strict architectural prompts that live directly where you work.
Prerequisites: You need either Cursor IDE (Highly Recommended for autonomous file writing) or Claude (via Claude Projects).
Cursor allows The Last PM to physically read your context, fetch agents, navigate folders, and write Markdown files directly to your local drive.
- Get the OS: Clone this repository or download it as a ZIP file.
- Open your Vault: Open the downloaded repository folder directly in Cursor.
- Set the Rules (Optional but Recommended): For a seamless experience, you can copy the contents of
LastPM.mdand paste them into your.cursorrulesfile. This makes the OS always active in the background. - Initiate the Orchestrator: Open the Cursor Chat (
Cmd + L), explicitly tag the Orchestrator, and state your problem.- Example:
@LastPM.md I just dropped 3 user interviews into the Backlog folder. Tell me what the biggest friction point is.
- Example:
If you don't use an IDE, you can run the OS using Claude's "Projects" feature, which acts as the system's memory.
- Create the Environment: Open Claude and create a new Project (e.g., "Product Vault").
- Upload the Brain: Upload the files from
00_OS_System_Filesand the entire/04_Agents/folder into the Project Knowledge base. - Set the Identity: Open
LastPM.md, copy all the text, and paste it into the "Custom Instructions" box for your Claude Project. - Start Building: Open a new chat inside the project and talk to your Chief of Staff.
- Note: Because Claude Web cannot physically write/organize files on your computer, it will output the final Markdown in the chat for you to copy/paste into your own notes.
You do not need to burn expensive premium tokens to run this OS.
Because The Last PM relies on a highly constrained, step-by-step architectural algorithm (The KERNEL Framework) rather than open-ended reasoning, it is exceptionally token-efficient. You do not need heavy-duty reasoning models for the daily workflow.
The system runs flawlessly on lightning-fast, lightweight models like Anthropic's Claude 3.5 Sonnet or Claude 3.5 Haiku.
The Benefit: You get near-instant agent execution, zero hallucination loops, and you save your premium IDE requests for complex coding tasks. The architecture does the heavy lifting, not the model.
The Last PM is a strictly structured file system designed to separate OS logic, static business context, and isolated project workspaces to prevent "Context Pollution."
📦 The-Last-PM
┣ 📜 LastPM.md # The Orchestrator (Paste into .cursorrules or Claude System Prompt)
┣ 📂 00_OS_System_Files # The Operating System Core
┃ ┣ 📜 agent_registry.md # Directory of all 50+ specialized agents
┃ ┣ 📜 intent_dictionary.md # Deterministic Semantic Routing Map
┃ ┣ 📜 scoring_matrix.md # The 0-10 Evaluation Rubric
┃ ┗ 📜 DECISION_template.md # Template for Product Decision Records (PDRs)
┣ 📂 01_Global_Context # The Static Brain
┃ ┣ 📂 01_Company_Context # company.md (Business model, burn rate, constraints)
┃ ┗ 📂 02_Product_Context # product.md (Current capabilities, OKRs, value props)
┣ 📂 02_Product_Workspace # The Localized Workspace (Where the work happens)
┃ ┗ 📂 [Your_Product_Name] # (e.g., DVA_Platform)
┃ ┣ 📂 00_Intake_and_Backlog # 📥 THE DROP ZONE: Raw transcripts, Zendesk tickets, raw ideas
┃ ┣ 📂 01_Global_Domains # Global Strategy & Docs mapped to the 10 Domains of Great Taste
┃ ┗ 📂 02_Initiatives # 🚀 THE BUILD ZONE: Feature-specific folders
┃ ┗ 📂 Feature_[Name] # PRDs, PDDs, and Initiative PDRs are stored locally here
┗ 📂 04_Agents # The Council of Titans (Your 50+ AI agents/frameworks)
┣ 📜 aha_moment_definer.md
┣ 📜 b2b_micro_loop_designer.md
┗ 📜 ... (and dozens more)
The Orchestrator operates as a strict, deterministic state machine. It actively manages the lifecycle of your ideas, promoting them from raw feedback to validated initiatives:
- The Intake (Drop Zone): You drop a raw transcript, feature request, or angry support email into the 00_Intake_and_Backlog folder.
- The Triage: You ask the OS to evaluate it. The OS selects a Discovery agent (like the Opportunity Score Calculator) to quantify the actual user pain.
- The Gatekeeper (Scoring): If the pain is real, you pitch building a feature. The OS reads the scoring_matrix.md and mathematically scores your pitch from 0-10 on Delight, Defensibility, Distribution, Monetization, and Feasibility.
- The Intervention: If your idea has a fatal flaw (e.g., 4/10 Monetization), the OS blocks you from writing a PRD. It automatically routes you to a strategy framework (like the Tiering Strategy Architect) to fix the flaw.
- The Checkpoint: After you provide inputs, the OS presents a brief, bulleted summary of its assumptions. You stay in control and must approve the direction before it writes any documents.
- The Promotion (Auto-Folder Creation): Once approved, the OS physically generates the Markdown document. If it's a new feature, it automatically creates a new 02_Initiatives/[Feature_Name] folder and moves the idea out of the Backlog into the Build Zone.
- The Memory: It prompts you to log a Product Decision Record (PDR) directly into that initiative's folder so the Vault never loses the "why" behind your pivot.
The OS is only as smart as the context you give it. To stop the AI from giving you generic, boilerplate advice, you must wire it into your specific product reality.
🧠 The Static Brain (Initialize your Vault)
Before you run your first agent, you need to define your playing field.
- Navigate to
01_Global_Context/. - Open and fill out the core templates:
company.mdandproduct.md. - Why this matters: Every time The Last PM runs a framework, it silently reads these files first. This ensures the pricing agent knows you are a B2B Enterprise SaaS (not a consumer app), and the strategy agent knows your current OKRs.
⚡ The Live Brain (MCP Integrations)
To unlock the absolute highest tier of autonomous product management, you need to connect the OS to your live tools using MCP (Model Context Protocol).
Because you are running this in Cursor, you can natively attach MCP servers to let The Last PM pull live data directly into the frameworks:
- Jira / Linear MCP: Connect your issue tracker. When you ask the OS to run a prioritization framework (like LNO or RICE), it can dynamically pull your current backlog, read the tickets, and re-rank them based on your current strategy.
- Notion / Google Drive MCP: Connect your knowledge base. Instead of copy-pasting customer interviews into the Intake folder, you can tell the Orchestrator: "Fetch the last 5 Gong transcripts from Notion and run the Jobs-to-be-Done (JTBD) agent."
- GitHub MCP: Connect your codebase. The OS can read PR velocity to understand true engineering constraints before proposing an aggressive roadmap.
Note: You don't need MCP to use The Last PM — you can always just paste your PRDs or transcripts directly into the 00_Intake_and_Backlog folder. But wiring up MCP turns the system from a consultant into a fully integrated Chief of Staff.