Why it should matter to you
I think I am not going to be the first person you ever heard to say, if you do not adopt AI in your ways of working, you can say goodbye to your current job, at least as a PM.
But the truth is it's kind of hard to keep up, when these tools change so fast.
Therefore, this is my attempt at describing the current state of AI's capabilities, and what you can do with it across the product development lifecycle.
The lifecycle, quickly
Before we go phase by phase, here's the product development lifecycle we're working with:
→ Discovery and research: figuring out what problem is real
→ Ideation and requirements: turning that problem into requirements
→ Design: shaping the solution
→ Development: building it
→ Testing: making sure it works
→ Launch: shipping it
→ Iteration and monitoring: watching what happens and feeding it back in
Nothing new here. What's new is how much of each phase AI can now touch.
So instead of forcing this into a simple ladder, here's what actually exists at each phase right now, as a list of distinct capabilities. Some of these will overlap with what you already use, some won't apply to your stack at all, that's fine. Pick what's relevant.
Discovery and research
WRITING COPILOTS
→ AI knowledge base researcher: searches your internal strategy docs, wikis, and past decisions and answers questions grounded in them. Especially useful for internal product work, where half of “discovery” is finding out someone already answered this question two years ago.
Tools to try: Glean, Onyx, Notion AI, Microsoft Copilot with Graph connectors
→ Business value / case research assistant: helps build the “why this matters” case: sizing the opportunity, framing ROI, pulling comparable numbers.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
→ Transcript analyzer: turns interview or call recordings into structured notes and pulls out themes, so you're not re-listening to find the one quote you needed.
Tools to try: Otter.ai, Fireflies.ai, Grain, Fathom
INTERVIEW COPILOT + STANDALONE AGENT
→ AI-moderated interview tools: the AI runs the interview itself, asks follow-up questions, and probes vague answers, useful when you need volume you can't get to manually.
Tools to try: Outset, Listen Labs, Strella, Userology
→ AI-moderated interview tools with synthesis: same as above, plus automatic theme clustering and a ranked synthesis across many interviews at once.
Tools to try: Outset or Listen Labs, paired with Dovetail for synthesis
BUILDING COPILOT
→ Quick technical discovery or validation: feasibility checks or a fast prototype to test a technical assumption before you commit real engineering time to it.
Tools to try: Claude Code, GitHub Copilot, Replit Agent, Lovable, Bolt.new
DATA / QUERY COPILOTS
→ Structured data query assistant: ask a plain-language question and get an answer pulled from a database or BI tool, useful for quantifying how big a problem actually is before you build the qualitative case. Different from the knowledge base researcher above, which searches documents, not tables.
Tools to try: ThoughtSpot Spotter, Power BI Copilot, Looker with Gemini
AUTONOMOUS AGENTS
→ Continuous discovery agent: runs in the background, recruiting and interviewing customers and synthesizing findings on its own, an always-on research stream instead of a study you launch and wait on.
Tools to try: Perspective AI, Enterpret
Ideation and requirements
WRITING COPILOTS
→ PRD or spec drafting assistant: turns rough notes into a structured first draft.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
→ Context-connected requirements assistant: connected to Notion, Confluence, or Teams, so it drafts against your actual company knowledge instead of generic best practice.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
→ User story generator: turns a feature description into a set of user stories with acceptance criteria.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
→ Stakeholder-facing summary drafting: translates a technical spec into something a non-technical stakeholder can actually read.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
ANALYSIS AND MONITORING COPILOTS
→ Prioritization or scoring assistant: runs RICE or MoSCoW scoring pulled from internal data instead of numbers you typed in from memory.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
→ Dependency or impact mapper: flags what existing systems or teams a change touches. Useful anywhere “simple requests” turn out not to be simple.
Tools to try: still an emerging category, most teams build this with Sourcegraph Cody or a custom Claude workflow against their architecture docs rather than a dedicated product
DECISION-SUPPORT / SIMULATION COPILOTS
→ Roadmap scenario simulator: models forward what happens to the roadmap or team capacity under different constraints, before you commit to a plan. Think “what happens if we cut this team's capacity 20 percent,” not a report on what already happened.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
Design
BUILDING COPILOTS
→ Prompt-to-wireframe generator: a rough layout from a text description, something to react to instead of a blank canvas.
Tools to try: Figma First Draft, Uizard, Galileo AI, Visily
→ Design-to-code handoff: generates a working prototype directly from the design file, not just specs for a developer to interpret.
Tools to try: Figma Make, Builder.io Visual Copilot, Anima
ANALYSIS AND MONITORING COPILOTS
→ Design system compliance checker: flags where a design drifts from your existing design system before it reaches engineering.
Tools to try: Figma AI design system checks, plus various Figma plugins
→ Accessibility or usability review assistant: checks a design against accessibility standards before it ships.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
TECHNICAL DESIGN AND ARCHITECTURE COPILOTS
→ Architecture and system design assistant: helps evaluate architecture options and draft technical design docs, for example weighing microservices against a monolith for a specific use case.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
→ Integration and dependency assessment: maps how a new feature or system will integrate with your other internal products, and flags conflicts before implementation instead of after.
Tools to try: Sourcegraph Cody, or a custom Claude workflow against your architecture docs, still a thin tooling category
→ Security or compliance review assistant: flags security and compliance risks in a technical design before it moves to development.
Tools to try: Snyk, Wiz, GitHub Advanced Security
Development
WRITING COPILOTS
→ Inline code completion: the assistant finishes the line you're already writing.
Tools to try: GitHub Copilot, Cursor Tab, Amazon Q Developer
→ Documentation generator: writes or updates technical documentation from the code itself.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
BUILDING COPILOT
→ Scoped in-editor coding agent: works one task at a time inside the editor, with a human reviewing each step.
Tools to try: Cursor, Windsurf, GitHub Copilot Workspace
AUTONOMOUS AGENTS
→ Autonomous coding agent: plans, writes, tests, and opens a pull request against a goal with minimal supervision, and can keep running for extended periods.
Tools to try: Claude Code, Devin, OpenAI Codex, Google Jules
→ Legacy code or migration assistant: handles large-scale refactors or migrations. One enterprise case had an agent complete a migration of over 100,000 data class implementations that was originally projected to take eighteen months.
Tools to try: Claude Code, Devin, Amazon Q's code transformation features
ANALYSIS AND MONITORING COPILOTS
→ Code review or PR assistant: reviews a pull request and flags issues before a human does.
Tools to try: CodeRabbit, GitHub Copilot code review, Greptile
ORCHESTRATION / MULTI-AGENT COORDINATORS
→ Multi-agent coordinator: routes work between specialized agents, one drafts, one tests, one reviews, instead of you triggering each step manually. Still early for most internal teams, but one of the bigger 2026 shifts to watch.
Tools to try: LangGraph, CrewAI, Microsoft Copilot Studio, n8n
Testing
WRITING COPILOT
→ Test case generator: generates test cases directly from your requirements doc.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
BUILDING COPILOT
→ Self-healing test automation: fixes broken tests automatically when UI elements change, instead of a QA engineer chasing every selector update.
Tools to try: mabl, Testim, Testsigma, Applitools
AUTONOMOUS AGENT
→ Agentic QA: owns your backlog directly, working against your existing Jira or GitHub issues rather than a separate test tool you have to keep in sync.
Tools to try: QA Wolf, Shiplight, testRigor
ANALYSIS AND MONITORING COPILOT
→ Security or compliance test assistant: runs security and compliance checks as part of the test cycle.
Tools to try: Snyk, GitHub Advanced Security AI detections
Launch and iteration
WRITING COPILOTS
→ Release notes or comms drafting: drafts release notes and a basic post-launch summary.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
→ Feedback loop synthesis: feeds monitoring and support signals back into discovery, so the loop actually closes instead of running one-way.
No new tool needed, a basic Claude, ChatGPT, or Copilot project handles this
ANALYSIS AND MONITORING COPILOTS
→ Anomaly detection and monitoring: learns what normal looks like and flags unusual patterns before they cross a hard threshold, catching the slow leak instead of only the sudden spike.
Tools to try: Datadog Watchdog, New Relic AI, Dynatrace Davis AI
→ Incident root-cause correlation: during an incident, correlates logs, metrics, traces, deployments, and feature flag changes to produce a working root-cause hypothesis instead of a blank dashboard.
Tools to try: Rootly AI SRE, PagerDuty, incident.io
→ Adoption or usage analytics assistant: surfaces how a feature is actually being used after launch, not just whether it shipped.
Tools to try: Amplitude, Mixpanel, Pendo
AUTONOMOUS AGENTS
→ Autonomous remediation agent: investigates an incident, executes the fix, and verifies it worked, rolling back automatically if it didn't, without a human approving each step. A step further than correlation: this one acts.
Tools to try: Resolve AI, Traversal, PagerDuty SRE Agent
Boss mode, make your agents talk
ORCHESTRATION / MULTI-AGENT COORDINATORS
→ Incident response coordinator: hands off between a monitoring agent, a correlation agent, and an action agent during an incident, rather than a human triggering each step.
Tools to try: Rootly, PagerDuty, incident.io, all now ship multiple specialized agents that hand off to each other
So what does this mean for you
Review the capabilities, and see if any of them can resolve the top challenging processes for you. For me personally, when I look at my own stack, it's really just two tools doing almost everything, Microsoft Copilot and GitHub Copilot, plus Snyk for security. The gaps are just as telling: I haven't touched interview tooling, multi-agent orchestration, or monitoring and remediation agents at all yet.
If you want to have the whole checklist to work against offline + my example of how my pipeline looks like now, download it below.
Checklist + how my pipeline looks like right now
Link to the checklist in Notion.
