ChatGPT Prompts That Run Projects Like a Senior PM

Create a comprehensive project kickoff document.

Project details:
- Project name: [name]
- Objective: [what are we building/achieving?]
- Sponsor/stakeholder: [who's funding or requesting this]
- Team: [roles and names]
- Timeline: [start date, target end date]
- Budget: [if applicable]
- Background: [why this project exists — the business need]

Generate a kickoff document with:
1. **Project charter**: Objective, scope, success criteria, out of scope items
2. **Stakeholder map**: Who needs to be informed, consulted, or has decision authority (RACI matrix)
3. **Milestones**: 5-8 key milestones with target dates
4. **Risk register**: Top 5 risks with likelihood, impact, and mitigation plans
5. **Communication plan**: Who gets what updates, how often, in what format
6. **Decision log template**: For tracking key decisions and rationale
7. **Success metrics**: How we'll know this project succeeded (quantifiable KPIs)
8. **Assumptions and dependencies**: What are we assuming is true, and what do we depend on?

Format this as a document I can paste into Notion, Confluence, or Google Docs. Use headers, tables, and bullet points for scannability.

Help me plan the next sprint.

Sprint details:
- Sprint number: [X]
- Duration: [1 week / 2 weeks]
- Team capacity: [X developers, Y designers, Z QA — note any PTO]
- Velocity last 3 sprints: [story points completed]

Product backlog items to consider:
[List the top items with brief descriptions and estimated story points]

Help me:
1. **Capacity calculation**: Based on team availability and historical velocity, how many story points can we realistically commit to?
2. **Sprint goal**: Write a clear, one-sentence sprint goal that the team can rally around
3. **Story selection**: Recommend which items to pull into the sprint, prioritized by:
   - Dependencies (what unblocks other work)
   - Business value
   - Technical risk (tackle risky items early)
4. **Story breakdown**: For any item over [X] story points, suggest how to break it into smaller stories
5. **Acceptance criteria**: Draft clear acceptance criteria for the top 5 items
6. **Risk flags**: Identify items that might spill over and suggest contingency plans
7. **Sprint board setup**: Suggested columns and swim lanes for this sprint

Present as a sprint planning summary I can share with the team.

Create a project risk assessment for my project.

Project: [brief description]
Timeline: [duration]
Team size: [number]
Key dependencies: [external systems, other teams, vendors, etc.]
Budget constraints: [any relevant limitations]

Identify risks across these categories:
1. **Technical risks**: Technology, architecture, integration challenges
2. **Resource risks**: Team availability, skill gaps, key-person dependencies
3. **Schedule risks**: Timeline pressure, external dependencies, seasonal factors
4. **Scope risks**: Requirement changes, stakeholder alignment, feature creep
5. **External risks**: Vendor dependencies, market changes, regulatory requirements

For each risk, provide:
| Risk | Category | Probability (1-5) | Impact (1-5) | Risk Score | Mitigation Strategy | Owner | Status |
|------|----------|-------------------|--------------|------------|---------------------|-------|--------|

Then:
- Highlight the top 3 risks that need immediate attention
- Suggest an early warning indicator for each top risk
- Recommend a risk review cadence (how often to revisit)
- Create a simple escalation framework: when should risks be escalated to leadership?

Generate a professional project status report.

Project: [name]
Reporting period: [this week / this sprint / this month]
Audience: [team / management / executives / client]

Current state:
- Overall status: [Green / Yellow / Red]
- Completed this period: [list key accomplishments]
- In progress: [list current work items and % complete]
- Blocked: [list any blockers and who can resolve them]
- Upcoming: [next period's planned work]

Generate a status report with:
1. **Executive summary** (3 sentences max — status, key win, key risk)
2. **Progress against milestones** (visual progress indicator)
3. **Key accomplishments** (bullet points, outcome-focused not task-focused)
4. **Risks and issues** (new this period + carried forward, with severity)
5. **Decisions needed** (what do you need from leadership?)
6. **Next period outlook** (what's planned + any concerns)
7. **Metrics dashboard** (velocity, burn-down, budget status, team health)

Write two versions:
- **Detailed** (for the team and direct stakeholders)
- **Executive summary** (3-4 bullet points for leadership — they won't read more)

Use [Red/Yellow/Green] status indicators and keep the tone factual, not defensive.

Help me facilitate a team retrospective.

Context:
- Sprint/project: [what we're reflecting on]
- Team size: [number of people]
- Duration: [30 min / 45 min / 60 min]
- Current team mood: [energized / neutral / frustrated / burned out]
- Previous retro action items: [list what was agreed last time]

Design a retrospective session:

1. **Opening activity** (5 min): An icebreaker or warm-up appropriate for the team mood
2. **Data gathering** (10-15 min): Choose a format:
   - Start/Stop/Continue
   - Mad/Sad/Glad
   - Sailboat (wind, anchors, rocks, island)
   - 4Ls (Liked, Learned, Lacked, Longed For)
   Recommend the best format for our current situation and explain why.

3. **Discussion prompts** (15-20 min): Specific questions to go deeper:
   - What surprised us this sprint?
   - Where did we waste the most time?
   - What would we do differently if we started over?
   - What did we learn that we should carry forward?

4. **Action items** (10 min): Framework for creating actionable improvements:
   - Maximum 3 action items (more than 3 never get done)
   - Each with a single owner and a specific deadline
   - Each measurable (how will we know we did it?)

5. **Accountability check**: Review last retro's action items — were they completed?

Also provide: 3 common retro anti-patterns and how to prevent them (blame games, same issues every sprint, no follow-through).

Create a stakeholder communication plan for my project.

Project: [name and brief description]
Duration: [timeline]

Stakeholders:
[List each stakeholder with: name/role, their interest in the project, their influence level]

Design a communication plan:

| Stakeholder | Interest | Influence | Update Frequency | Format | Content Focus | Owner |
|-------------|----------|-----------|-----------------|--------|---------------|-------|

For each stakeholder group, provide:
1. What they care about (translate project updates into their language)
2. What format works best (email, Slack, meeting, dashboard)
3. How much detail they want (exec summary vs. full detail)
4. When to proactively communicate vs. wait for them to ask
5. How to handle bad news (timing, framing, solutions-first approach)

Also create:
- An escalation matrix: Who to contact for different severity levels
- A RACI chart for key project decisions
- Templates for the 3 most common communications:
  - Weekly status update
  - Risk/issue escalation
  - Milestone completion announcement

Create an effective meeting agenda.

Meeting type: [kickoff / standup / planning / review / decision-making / brainstorm / 1:1]
Duration: [X minutes]
Attendees: [list roles, not just names]
Purpose: [what must be accomplished by the end of this meeting]
Context: [what's happening that makes this meeting necessary]

Generate:
1. **Pre-meeting prep**: What attendees should read/review before the meeting (keep it under 10 minutes of prep)
2. **Agenda with time boxing**:
   | Time | Topic | Owner | Purpose (Inform/Discuss/Decide) | Output |
   |------|-------|-------|-------------------------------|--------|
3. **Opening question**: A specific question to focus the discussion from minute one
4. **Decision framework**: If decisions need to be made, how will we decide? (consensus, majority, HIPPO, etc.)
5. **Parking lot rules**: How to handle tangents without shutting down good ideas
6. **Closing**: Last 5 minutes — recap decisions, assign actions, confirm next steps

Also provide:
- A "should this meeting even exist?" checklist (could this be an email/Slack message instead?)
- Notes template for the meeting scribe
- The one question to ask at the end that ensures the meeting was worth everyone's time

Help me optimize resource allocation across my project(s).

Available team members:
[List each person with: name, role, skill set, current allocation %, availability constraints]

Current/upcoming work:
[List projects or workstreams with: priority (P0/P1/P2), estimated effort, required skills, deadline]

Analyze and recommend:
1. **Allocation matrix**: Who should work on what, for what percentage of their time?
2. **Skill gap analysis**: Where do we have too few people with the right skills?
3. **Over-allocation risks**: Who is assigned more than 100% and what's the impact?
4. **Bus factor analysis**: Which projects have single-point-of-failure dependencies on one person?
5. **Flexibility assessment**: If priorities shift, where do we have slack to reassign?

Present as:
| Person | Project A (%) | Project B (%) | Project C (%) | Total | Risk Flag |
|--------|--------------|--------------|--------------|-------|-----------|

Also flag:
- Context-switching concerns (anyone split across 3+ projects)
- Upcoming conflicts (two high-priority deadlines in the same week)
- Recommendations for cross-training to reduce bus factor

Help me estimate a realistic project timeline.

Project scope:
[Describe what needs to be built/delivered — features, deliverables, phases]

Team: [size and composition]
Dependencies: [external teams, vendors, approvals needed]
Known constraints: [hard deadlines, holidays, team availability gaps]

For each major workstream or phase:
1. **Optimistic estimate**: If everything goes perfectly (it won't)
2. **Realistic estimate**: Based on typical project reality (add 30-50% buffer)
3. **Pessimistic estimate**: If key risks materialize

Present as a Gantt-style text timeline:
| Phase | Start | End (Optimistic) | End (Realistic) | End (Pessimistic) | Dependencies | Risk Factor |
|-------|-------|-----------------|-----------------|-------------------|--------------|-------------|

Then:
- Calculate the critical path (the longest chain of dependent tasks)
- Identify where parallelization can save time
- Flag milestones where external dependencies could block progress
- Suggest 3 specific things we could cut to meet a tighter deadline (scope trade-offs)
- Recommend buffer placement (don't spread it evenly — put buffers after high-risk phases)

Create comprehensive handoff documentation for a project or feature transitioning to another team.

What's being handed off: [project/feature/system name]
From: [your team/role]
To: [receiving team/role]
Handoff date: [when]
Ongoing support period: [how long your team will be available for questions]

Generate handoff documentation covering:

1. **Overview**: What this is, why it exists, who uses it
2. **Architecture/system design**: How it works at a high level (include a text diagram if applicable)
3. **Key decisions log**: Major decisions made and WHY (not just what)
4. **Known issues and tech debt**: What's imperfect and what the receiving team should know
5. **Runbooks**: Step-by-step procedures for common operations:
   - How to deploy
   - How to rollback
   - How to debug common issues
   - How to handle incidents
6. **Access and credentials**: What access the receiving team needs (don't include actual credentials — just what to request)
7. **Monitoring and alerts**: What's monitored, where dashboards are, what alerts mean
8. **Contact list**: Who to reach out to for specific questions during the transition
9. **FAQ**: Anticipated questions from the receiving team based on my experience
10. **Training plan**: Recommended sessions to get the receiving team up to speed

This document should enable the receiving team to operate independently within [X weeks].