SkillAgentSearch skills...

product-manager

When you want to plan, build, or check an app from idea through launch readiness — web, Apple, mobile, or extensions. Writes the brief, picks the stack (Next.js + TypeScript + Prisma by default, Swift on Apple), designs complete UX states, defines roles and agent access, measures performance before…

Install / Use

npx skills add coreyhaines31/makerskills --skill product-manager

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

85/100

Supported Platforms

Universal

Our assessment of product-manager

product-manager scores 85/100 on our quality scale, 2745th of 4,704 Development & Engineering skills we index.

Its SKILL.md is 16 KB long, well organised into 12 sections and no code examples: a thorough specification that gives an agent plenty to work with.

It has 824 GitHub stars, a meaningful sign that others use it.

Substance
30/30
Structure
13/20
Description
15/15
Adoption
12/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 25 days ago, so product-manager is actively maintained.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-10. Automated pattern scan on 2026-11-10. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

product-manager compared with similar skills

All 4 of these similar skills score higher than product-manager; compare them before choosing.

SkillScoreStarsUpdatedFormat
product-manager (this skill)by coreyhaines318582425d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md

Frequently asked questions

How do I install product-manager?
Run npx skills add coreyhaines31/makerskills --skill product-manager. The install tabs above show the steps for each supported agent.
Which AI agents does product-manager work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is product-manager safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is product-manager still maintained?
The repository was last updated 25 days ago, so product-manager is actively maintained.

name: product-manager description: "When you want to plan, build, or check an app from idea through launch readiness — web, Apple, mobile, or extensions. Writes the brief, picks the stack (Next.js + TypeScript + Prisma by default, Swift on Apple), designs complete UX states, defines roles and agent access, measures performance before optimizing, and produces a readiness report where missing evidence is never a pass. Four modes: spec (plan v1), check (launch readiness), audit (ranked improvements, including what a new model changes), fleet (a named list of apps). Triggers on "/product-manager," "act as my product manager," "PM this app," "build me an app," "plan v1," "spec this app," "is this app ready to launch," "launch readiness," "audit my apps," "what's missing before we ship," "do a comprehensive audit," "how could we improve my app," "a new model just came out." Not for launch marketing or growth (see launch), integration plumbing (see toolify), CI cost (see ci-audit), or managing a project backlog/kanban (see project-manager)." metadata: version: 0.5.0

/product-manager — Take an app from idea to launch-ready

Most apps that fail at launch don't fail on the main feature. They fail on what nobody specced: a client who can download another client's files, an invite button that sends twice on a slow network, a backup nobody ever restored, a cache keyed on project ID that leaks internal notes. This skill makes you decide those things up front, and then proves them before calling anything ready.

It ends at launch-ready, not launched. Promotion, SEO, launch posts and growth go to the marketing skills.

Mental model

  • Applicability, not parity. A local macOS timer doesn't need organizations. A collaborative SaaS does. Choose a platform profile, then check what applies.
  • Evidence, not vibes. Every requirement ends up as pass, gap, not assessed, or justified N/A. Missing evidence isn't a pass.
  • Measure, then fix. Broken before slow. Baseline before cache.
  • Complement the model. Build what gets more useful as models improve.

Step 0 — Pick the mode

| Mode | When | Output | |---|---|---| | spec | New app or v1 plan | Brief, stack, UX states, access model, test plan | | check | Existing app, "are we ready?" | Readiness report (read-only by default) | | audit | Existing app, "how could this be better?", or a new model just shipped | Ranked findings, model lens, comparison with the last audit (read-only) | | fleet | A named list of apps | One short report per app + a cross-app summary |

Ask which mode if it isn't obvious.

What each step does per mode:

| Step | spec | check / fleet | audit | |---|---|---|---| | 1 Brief | Write it; pick profile + stack | Infer it from the repo, confirm the gaps; keep the existing stack | Load the brief and the last audit; infer if missing | | 2 UX | Design the states | Audit the states that exist → report rows | UX lens → findings | | 3 Trust | Define the model | Audit it → report rows | Trust lens → findings | | 4 Build + proof | Plan units and tests | Map existing tests to journeys; note gaps | Proof and agent-ready-codebase lenses → findings | | 5 Performance | Plan baselines only (nothing to measure yet) | Measure with existing evidence | Performance lens, existing evidence only | | 6 Report | Baseline report, mostly not assessed, verdict unproven | Full readiness report | Audit report from references/audit.md. No launch verdict |

Skipping a step under time pressure is fine. Its rows become not assessed, never pass.

Where output goes. Spec: docs/product/spec.md in the app's repo. Show it before writing, and if there's no repo, show it in chat and ask where it should live. Check: show the report in chat and offer to save docs/product/readiness-<YYYY-MM-DD>.md. Audit: show it in chat and offer to save docs/product/audits/<YYYY-MM-DD>-<model-slug>.md. The next audit reads it to show what changed. Fleet: one report per app plus a summary table in chat.

Read-only and approvals. In check, audit and fleet, stay read-only unless the user asks for fixes. If they ask for a fix, draft it on a branch and keep the report's statuses unchanged until it's verified. Record the exact revision and environment: for web, branch/commit plus staging/prod; for native, OS version, hardware, and debug/release/signed build. When you lack access to something (deploy logs, production data), mark it not assessed instead of working around it. In fleet, use the list the user gives you. Don't go discovering every repo.

| Action | Needs | |---|---| | Reading code, config, existing logs and stats | Nothing beyond access | | Read-only queries against production (stats, plain EXPLAIN on a SELECT) | A yes naming the exact statements, with a read-only role | | Anything that executes writes, sends mail, charges, migrates, flushes a cache (incl. EXPLAIN ANALYZE on writes, test suites with live keys) | A sandbox (restored copy, branch DB, fake mailer, test-mode keys) and a yes naming the exact command | | Submitting or publishing anything (notarization, store, deploy, posts) | The user runs it, or gives a yes naming the exact command. Check mode never submits on its own. Hold off if the credential it relies on was just leaked |

Check for live keys in the test env and real addresses in fixtures before calling anything sandboxed. If a composed skill isn't installed, say so and use this skill's references.

Audit mode

Read references/audit.md and follow it. It runs Steps 1–5 as lenses on the existing app, plus a model lens: inventory every model call, get current model facts from the claude-api skill or official docs (never memory), and ask what the new model makes obsolete, newly possible, removable or stale. Findings are ranked by impact, confidence and effort, and each one cites evidence. If there's a previous audit, lead with what's fixed, still open, new, and changed because of the model. Picked findings can go to /improve plan. Nothing is implemented without a yes.

Step 1 — Write the brief

Ask the two questions that decide the most first: which platform (web, iPhone, Mac, extension) and who uses it (just me / one team / many orgs). Then get these down in a few lines each. Ask for anything you can't infer from the repo. If the user says "you pick", draft it, mark each guess (assumed), and move on. The exception is choices that are hard to reverse (where data lives, whether there's auth, single- vs multi-tenant): state your pick and get a one-word OK. Batch follow-up questions into one message:

  • Audience and the job they're hiring this for. What's their current workaround?
  • Useful outcome: what "done" looks like for the user.
  • Critical journeys: first use, return visit, recovery.
  • v1 in / out, and acceptance criteria.
  • The better-model test: if the next model is much better at the intelligence part, does this get more useful or less? Write down what the product contributes. For a non-AI app, one line is enough.

Then pick a platform profile and stack. Read references/standards.md. Defaults for new web apps: Next.js + TypeScript + Tailwind + shadcn/ui + Prisma ORM + Prisma Postgres, plus Better Auth when there are accounts and Stripe when there's billing. Swift for Apple platforms. Existing apps keep their stack. Note any departure and why.

Step 2 — Design the experience

Read references/ux.md. For each critical journey, name:

  • the happy path, and the one primary action at each step
  • every state: empty, invalid, denied, sending, partial, timeout/failure, offline, success, recovery (mark the ones that can't happen as N/A, e.g. offline for a local-only app). Two-sided products get journeys per audience
  • where contextual help goes: tooltips and helper text for unfamiliar metrics, settings, permissions and unavailable actions. Errors and essential instructions stay inline, never only in a tooltip.
  • the consequential actions that need preview, confirm or undo

Minimize total effort, not raw clicks. Read .agents/brand.md / .agents/design.md if they exist. For visual direction, route to a design skill from the table in references/ux.md: Zach Stevens' brand / creative-direction when there's no identity yet, impeccable or frontend-design for direction, hallmark so it doesn't look generated, Emil Kowalski's skills for interaction craft, web-design-guidelines or swiftui-pro for review. Don't invent a house style. Output a short design record: chosen direction, the states table, and what's still a proposal.

Step 3 — Define boundaries and trust

Read references/trust.md. Check the five outcomes against the profile:

  1. Users, orgs, teams, roles (if collaborative): access matrix and negative tests.
  2. Feedback: free text, screenshots, video, with consent and private uploads.
  3. Security that fits the risk: threat model, least privilege, secrets, sessions, webhooks. For depth, route to Brie Russell's cybersecurity-skills (threat-modeling, owasp-audit, api-audit, secrets-audit and more; table in references/trust.md).
  4. Privacy-aware analytics: decisions first, minimal payloads, or none at all.
  5. Agent access: one useful workflow through API/CLI/MCP, using the same policy as the UI.

Mark each applies / justified N/A. Don't add infrastructure just to tick a box. Keep the two "agent-friendly" questions apart: a codebase a coding agent can safely change, and a product an external agent can safely operate.

Step 4 — Plan the build and its proof

Break accepted requirements into small units, each with an acceptance check and a rollback. Read the testing section of references/readiness.md. Map each critical journey and invariant to its cheapest meaningful proof: unit tests for policy, integration tests for tenant boundaries and webhooks, a few e2e tests for real journeys.

If the user wants it built, build it in small commits following the repo's workflow. Route integration plumbing to toolify and GitHub Actions cost and timing to ci-audit.

Handing units to another agent. If improve (shadcn) is installed, use /improve plan <unit> to turn each accepted unit into a self-contained plan in plans/, with its acceptance check as the verification gate. A cheaper model can then execute it. Run /improve branch before each PR. Merging stays with the user, and --issues publishes plans as GitHub issues, so only use it with a yes.

Step 5 — Measure performance, then improve

Read references/performance.md. If front-end-performance-audit, back-end-performance-audit or database-performance-audit are installed, use them. Otherwise follow the reference.

Broken before slow → baseline → find the limiter → rank → user picks → apply → remeasure comparably. Fill in the cache contract before recommending any cache. Authorization is still checked on every cache hit. Never claim a speedup you didn't measure.

Step 6 — Readiness report

Read references/readiness.md and fill in its report template. One row per applicable requirement:

  • pass: verified at a stated revision and environment
  • gap: verified as unmet; say if it blocks
  • not assessed: no access, no evidence, or not tested
  • justified N/A: doesn't apply to this profile, with the reason

The evidence rules are in references/readiness.md. Reading code can prove a mechanism is missing, but not that one works. A named manual run counts only for the paths that were actually exercised.

Verdict: any verified blocking gap → not ready. No blocking gaps, but a critical control (tenant isolation, secrets, restore, the release path) is not assessed → unproven. Otherwise → ready for review.

End with the verdict for the stated scope, blockers, unknowns, and one next step. Keep drafted, checked, m

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars824
CategoryDevelopment
Updated25d ago
Forks67

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions