Beyond PRDs: 7 Codex Skills Every Product Manager Should Install First

Why Skills Matter More Than Prompts

Many product managers already use Codex for one-off tasks like writing PRDs, summarizing meetings, or generating user stories. However, if every interaction requires re-explaining business context, analytical frameworks, and output formats, Codex remains a temporary contractor rather than an integrated part of the workflow. OpenAI defines a Skill as a reusable task workflow that can include instructions, templates, examples, and supporting resources. Codex can automatically select the appropriate Skill or be invoked explicitly via $SkillName. A Skill functions like a standard operating procedure: it does not make judgments for you, but ensures the AI starts each task with a consistent, repeatable method — exactly what product managers do when turning chaotic information into executable processes.

Seven Skills Covering the Full Product Discovery Loop

The following seven Skills map to the end-to-end product discovery chain: requirement collection → user research → opportunity identification → solution prioritization → metric validation → solution expression .

1. analyze-feature-requests: Clean the Requirement Pool First

Product managers rarely receive requirements in a standard format. Support tickets, sales demands, executive ideas, and operational retrospectives arrive mixed together — some are feature suggestions, some are experience issues, some are business requests, and some are merely individual preferences. analyze-feature-requests performs a first-pass structured cleaning:

Group similar feedback into themes

Identify affected users and usage scenarios

Distinguish surface requests from underlying problems

Assess evidence strength and strategic fit

Output problems worth further validation

You can feed it support tickets, interview excerpts, sales feedback, or requirement spreadsheets to produce a "discussable requirement map."

Use analyze-feature-requests to analyze this batch of requirements. Categorize by theme, target user, real problem, evidence strength, and strategic fit; do not give scheduling conclusions directly; also flag items with insufficient information that need further validation.

The Skill filters noise; the PM decides what is worth building.

2. interview-script: Stop Turning User Interviews into "Seeking Validation"

Many interviews go wrong at the question-design stage. Questions like "Would you use this feature if we built it?", "Do you think this solution has value?", or "Don't you also need a smarter tool?" easily elicit affirmative answers but produce unreliable evidence. Users' predictions about future behavior are far less valuable than their past actual behavior. interview-script generates a structured interview guide around a research objective, pulling questions back to concrete scenarios, past behaviors, alternatives, decision processes, and incurred costs, reducing leading questions.

Use interview-script to design a 45-minute interview guide for "Why new users fail to complete their first core task." Focus on the most recent real experience, the goal at that moment, blockers, alternatives, and reasons for abandonment; avoid asking whether users like a yet-to-be-developed feature.

A good script isn't about writing more questions; it's about ensuring every question serves a hypothesis that needs validation.

3. summarize-interview: Find the Real Problem from Users' Own Words

A one-hour interview can yield tens of thousands of words of transcript. The real challenge isn't compression but separating three things: what the user said, why they said it, and what the team should validate next. summarize-interview breaks interview material into JTBD (Jobs To Be Done), pain points, motivations, satisfaction/dissatisfaction signals, current alternatives, key verbatims, and follow-up actions.

For example, a user says "I need to export Excel." The underlying job may not be "get a file" but "submit a weekly report to my boss that can be further processed." If only the feature request is recorded, the team may build the right feature yet still fail to solve the problem.

Use summarize-interview to analyze this interview record. Present facts, user judgments, and your inferences separately; extract JTBD, main obstacles, alternatives, key evidence, and hypotheses to validate, and attach the original verbatim for each insight.

The most critical constraint here is: separate facts from inferences . The smoother the AI's summary, the more the PM must return to the raw evidence for verification.

4. opportunity-solution-tree: Don't Jump Straight from Problem to Feature

Conversion drops → change the button; new users struggle → add onboarding; retention suffers → build an incentive system. These solutions may not be wrong, but jumping from business outcome directly to feature skips the most important layer: the opportunity. opportunity-solution-tree structures thinking as "Desired Outcome → Opportunities → Solutions → Experiments," helping the team answer:

What outcome do we want to change?

Which user problems block that outcome?

What possible solutions exist for each problem?

Which solution is worth validating first with a low-cost experiment?

Use opportunity-solution-tree to build an opportunity-solution tree around "Increase new-user first-week activation from 32% to 40%." Opportunities must come from provided research evidence; each opportunity must have at least three distinct solution types, and each solution must include a minimum viable experiment design.

The tree's greatest value is shifting discussion from "What feature should we build?" back to "What problem are we solving?"

5. prioritize-features: Generate a Sortable, Challengeable Draft Ranking

Prioritization meetings are never just about scoring. Executives care about strategy, sales about customer commitments, engineering about implementation cost, operations about campaign windows. The PM's job is to get different roles discussing the same facts and constraints. prioritize-features produces a draft ranking based on impact, cost, risk, evidence, and strategic alignment, explaining the rationale for each score. It doesn't make the final call, but it reduces time spent arguing from zero.

Use prioritize-features to rank these 12 candidate requirements. First state the dimensions and weights you use, then list each item's score, evidence, assumptions, and risks. Lower confidence for items with insufficient evidence; do not fill gaps with fabricated data.

True professional prioritization isn't a precise-looking score table; it's that every score is traceable and every assumption is challengeable.

6. metrics-dashboard: Answer "How Do We Prove It Works" Before Launch

Goals like "improve user experience," "increase stickiness," or "boost conversion efficiency" slide easily into a PRD but cannot guide a retrospective. metrics-dashboard breaks vague goals into a North Star metric, input metrics, guardrail metrics, and alert thresholds, complete with definitions, calculation formulas, data sources, observation windows, and owners.

For a new onboarding flow, the team might need to track simultaneously:

Core task completion rate

Step-by-step conversion rates

Time to Aha Moment

Drop-off rate during onboarding

Day-1 or Day-7 retention

Side effects on existing users, performance, or support volume

Use metrics-dashboard to design a launch dashboard for "New Onboarding v2." Provide core outcome metrics, input metrics, and guardrail metrics, with definitions, calculation formulas, data sources, observation windows, alert thresholds, and owners. If baseline data is missing, explicitly mark it; do not assume values.

If a feature cannot articulate how it will be validated before launch, the issue is usually not data capability but that the problem hasn't been thought through deeply enough.

7. imini-api-integration-skill: Turn Abstract Solutions into Visible Expressions

The first six Skills address product thinking; the seventh addresses product expression. PMs often need the team to share a mental model of something that doesn't exist yet. Pure-text PRDs struggle to convey UI atmosphere, flow relationships, campaign concepts, or product visions efficiently. A single diagram or concept video can be more effective than three pages of description. imini-api-integration-skill is a third-party multimodal generation Skill that helps Codex select image or video models and handles async submission, task polling, result extraction, cost estimation, and error retry.

Use imini-generate to create a 16:9 process concept diagram suitable for a product review deck, illustrating four steps: "Upload meeting recording → AI transcription → Extract action items → Sync to calendar." Use a clean B2B SaaS visual style, emphasize the flow, do not make it a marketing poster.

Caution: This is a third-party service; model calls may incur costs. When real user data, unreleased product info, or internal materials are involved, confirm organizational data-security requirements first and use sanitized assets.

How to Install

The first six Skills come from the open-source repository phuryn/pm-skills (plugin pm-product-discovery). Using the current Codex installation method, run in terminal:

codex plugin marketplace add phuryn/pm-skills
codex plugin add pm-product-discovery@pm-skills

The seventh Skill can be installed separately:

npx skills add imini-ai/imini-api-integration-skill

To actually call the iMini API, you need an API Key from their official site, configured via environment variables. Never hard-code the Key in code, PRDs, or chat messages. Installation methods may vary across Codex versions and repositories; always refer to official documentation and the project README before proceeding.

Don't Install All at Once: Start with Your Most Repeated Weekly Task

Skills are not collectibles; more is not better. Installing too many can add context noise if they don't match the team's real process. A practical approach: ask yourself "What work do I repeat at least two or three times a week, has relatively fixed steps, and consumes a lot of time?"

If the requirement pool is always messy, start with analyze-feature-requests.

If intensive interviews are coming up, combine interview-script and summarize-interview.

If sprint planning meetings are full of disputes, try prioritize-features first.

If retrospectives stall at "feels good," bring metrics-dashboard into the requirement review.

After the first run, don't rush to judge "good or bad." Instead:

Compare against manual results; check what it missed or misjudged.

Feed the team's metric definitions, templates, and decision principles back into the workflow.

Run a real task again until output stabilizes and becomes usable.

When a Skill truly integrates into the workflow, what it codifies is no longer a clever prompt but a team-approved working method.

Final Thought

Codex won't automatically become a senior product manager just because you installed seven Skills. It cannot understand organizational context for you, cannot make trade-offs for you, and cannot own outcomes for you. But it can handle large volumes of repetitive organizing, decomposition, and structuring work, freeing the product manager to focus on the scarcer parts: identifying the real problem, judging whether evidence is credible, balancing multi-party constraints, and driving team consensus.

The future gap in AI usage among product managers may not be about who writes the most magical prompt, but about who first turns their own methodology into a stable, callable, continuously iterated work system.

Skills can clear the deck. Direction still belongs to the product manager.