product-owner
Skill1 starsChanged 2 months agoApache-2.0View on GitHub
Use this skill for judgment calls about what Compendium (brylie/compendium) should be, not just how to track it — editing or evaluating docs/prd.md itself, deciding whether Phase 0 is actually done and it's time to open Phase 1, checking whether a proposed feature crosses one of the PRD's stated Non-Goals, deciding whether a P1/P2 requirement should be pulled forward into current work, triaging a piece of dogfooding friction into a PRD gap vs. a backlog issue, verifying a requirement's acceptance criteria are actually met (not just that a PR merged), checking a proposed docs/specifications/*.md addition fits the PRD's Core Architectural Principle before it's written, or re-checking a load-bearing external/competitive claim the PRD depends on. Trigger this any time the user asks things like "does this fit the PRD", "should we open the next phase", "is this in scope", "what's next on the roadmap", "does the PRD need updating", "is this actually done" for a PRD requirement, or raises a product-direction question rather than a tracking/prioritization one — even if they don't say "PRD" or "product owner" explicitly. For per-issue tracking mechanics (priority, sizing, relationships, grooming) use the backlog-refinement skill instead; this skill decides what belongs in the backlog, backlog-refinement makes sure it's tracked correctly once it's there.
14 other projects use a version of this.
Adopted by
Most recently taken up by
- prygrn/agent-kerneltheir own version, first seen Nov 15, 2026
- chrysogonus/prompt-maker-studiotheir own version, first seen Nov 15, 2026
- bookchaowalit/platform-agent-skillstheir own version, first seen Nov 8, 2026
- SecuringTheRealm/str-mcp-purviewtheir own version, first seen Nov 1, 2026
- jpantsjoha/ai-native-developer-experiencetheir own version, first seen Nov 1, 2026
- dpalfery/kyber-weavetheir own version, first seen Oct 25, 2026
Other versions14 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 14
- dpalfery/kyber-weave★ 23same name
- jpantsjoha/ai-native-developer-experience★ 13same name
- fusebase-dev/fusebase-flow★ 9same name
- chrysogonus/prompt-maker-studio★ 7same name
- CrashBytes/claude-role-skills★ 7same name
- SecuringTheRealm/str-mcp-purview★ 4same name
- ckifonidis/claude-code-skils★ 2same name
- Finntegrate/tapio★ 2same name
- tomas-u/claude-skills★ 2same name
- CrashBytes/claude-product-owner★ 1same name
4 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository7 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- code-reviewSkill
- pr-backlog-reflectionSkill
- pull-request-reviewSkill
- backlog-refinementSkill
- quality-assuranceSkill
- ux-designerSkill
The file
We split this skill into the rules it gives an agent
11 rules. 0 are common, 7 are distinctive, and 4 are very specific to this project.
0
Common
Most of the 14 edited versions we read keep these.
7
Distinctive
This author's own choices. Worth a look.
4
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 86
Read the Timeline Considerations section's definition of what the _next_ phase actually adds (Phase 1 = multi-human collaboration + auth.
- Distinctive: line 89
Check whether Phase 0's qualitative bar is actually met — this requires asking the user directly, since only they know whether they're …
- Very specific: line 104
Every Requirement bullet (P0/P1/P2) should map to a filed issue, or be identifiably already done.
- Very specific: line 125
Every P0 Requirement's _Acceptance:_ clauses are the actual definition of "done" — a merged PR or a checked checklist box is a proxy for …
- Distinctive: line 130
Check whether there's test coverage or a manual verification that actually exercises each one — not just that the surrounding feature works …
- Distinctive: line 133
If a clause isn't demonstrably met, say so plainly rather than deferring to "the PR merged, so it's probably fine" — this is exactly the …
- Distinctive: line 148
Ask: is there genuinely new evidence since the Non-Goal was written, or is this the same case already considered and rejected?
- Distinctive: line 152
If there's no new evidence, say so directly and don't implement it — the PRD's own language is explicit that revisiting these needs a real …
- Distinctive: line 155
If there genuinely is new evidence, that's a §1 PRD-stewardship edit (update the Non-Goal's own text to reflect the reconsideration), not a …
- Very specific: line 240
Read docs/prd.md in full — it's short enough (~300 lines) that a partial read risks missing a Non-Goal or an already-settled decision.
- Distinctive: line 246
Ask whether Phase 0's qualitative bar looks met (§2) — surface the question, let the user answer it.
“Common” is measured: kept by at least 6 in 10 of the 14 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Product ownership (brylie/compendium)
docs/prd.md is this repo's product source of truth — "Status: Draft for
review," Owner: Brylie Christopher Oxley, and per CLAUDE.md it's treated as
canonical, not aspirational. This skill is how it stays that way: judgment
calls about what the product should be, phase-gating, non-goal enforcement,
and roadmap sequencing — the layer above backlog-refinement, which assumes
the PRD is already right and just makes sure issues correctly reflect it.
Division of labor, concretely: this skill decides whether something
belongs in the product and when; backlog-refinement decides how it's
tracked once that's settled. When this skill's work produces new backlog
work (a PRD gap needs an issue, a pulled-forward P1 item needs re-prioritizing),
hand off to backlog-refinement for the actual filing/prioritizing rather
than duplicating that logic here.
The one rule that overrides everything else here
Show the user the exact diff to docs/prd.md, and wait for their
go-ahead, before writing it — every time, regardless of size. "I'm
confident this is the right call" is not the same thing as the user having
agreed to it, and a product-direction edit — unlike a board field — has no
mechanical dry-run wrapper to enforce this for you. Draft the exact edit,
show it, wait for agreement, then write it. It's git-tracked and reversible
either way, but that's a safety net for mistakes, not a substitute for
asking first.
This same gate covers docs/specifications/*.md too, but only for what
this skill actually owns there: a §9 architecture-conformance judgment call
on a proposed spec, or a standalone spec correction that isn't tied to
implementing an already-scoped issue. It does not cover a spec update
written as a routine part of implementing an issue whose scope the user
already approved — CLAUDE.md's own implementation workflow already handles
that case (write the spec as part of the same change; the PR itself, which
the user reviews before merge, is the confirmation gate for that kind of
edit). Don't require a second stop-and-confirm on top of a review the user
is already going to do.
PRD structure map
docs/prd.md's sections, in order, and what each is for — read the section
itself before acting on it; this is a map, not a substitute:
| Section | What it's for |
| Problem Statement | The thesis this whole project is betting on |
| Goals / Non-Goals | What's in scope and — just as load-bearing — what's deliberately excluded and why |
| Target Users | Personas; note Phase 0 collapses several personas onto one person |
| User Stories | Per-persona scenarios; the concrete cases Requirements exist to satisfy |
| Core Architectural Principle | The unified record/Document/Collection/View model — the thing a new spec must not violate |
| Requirements | Must-Have (P0) / Nice-to-Have (P1) / Future Considerations (P2) — only P0 items carry explicit _Acceptance:_ clauses today |
| Success Metrics | Leading/lagging indicators — explicitly Phase 1+ only; Phase 0's bar is qualitative |
| Open Questions | Currently empty ("ready to move into engineering scoping") — don't treat this as invalid just because it's short |
| Timeline Considerations | The Phase 0/1/2/3 definitions and what triggers moving between them |
1. PRD stewardship
The PRD documents its own edit history inline (e.g. "Reordered 2026-08-26 around dogfooding priority," the product-rename note at the top) — every edit this skill makes should be legible the same way: a reader six months from now should be able to tell that something changed and why without needing git blame. When you edit Goals/Non-Goals, User Stories, or a Requirement's tier, add a short inline note in the same style if the change isn't self-explanatory from context.
Common edits this responsibility covers: retiring a User Story invalidated by real usage, adding one revealed by a new persona/workflow, moving a Requirement between P0/P1/P2 tiers, or correcting Goals/Non-Goals language that no longer matches the product's actual direction. Apply the write-confirmation rule above to all of these.
2. Phase-gating decisions
Phase 0's bar, per the PRD's own Success Metrics section, is deliberately qualitative: "does the founder actually keep using this daily... instead of reverting to Notion/docs/chat for the same task." Don't substitute a quantitative proxy for this (issue count closed, PRs merged) — those measure output, not the actual question. When asked whether it's time to open the next phase:
- Read the Timeline Considerations section's definition of what the next phase actually adds (Phase 1 = multi-human collaboration + auth; Phase 2 = views/multi-space/editor depth; Phase 3 = scale/automation/ecosystem).
- Check whether Phase 0's qualitative bar is actually met — this requires asking the user directly, since only they know whether they're actually using it daily, not inferring it from repo activity.
- Note explicitly that several P1/P2 items are already being pulled forward into Phase 0 (see §6) — a phase "opening" doesn't mean nothing from it exists yet, it means the phase's defining gap (e.g. Phase 1's auth/ multi-human collaboration) is the next thing being deliberately built.
This is a recommendation-and-discussion call, not something to decide unilaterally — surface your read of the evidence and let the user make the actual call, the same way Phase 0's bar itself is intentionally founder-judged rather than metric-gated.
3. Requirement ↔ issue traceability
Every Requirement bullet (P0/P1/P2) should map to a filed issue, or be identifiably already done. Two failure modes, both worth flagging:
- Orphaned requirement — in the PRD, no tracking issue exists yet. This
is invisible to planning until it's filed. Hand off to
backlog-refinementwith the requirement's own text, its PRD tier (P0/P1/P2), and its_Acceptance:_clauses — that's the raw material for the issue's own "Done when:" line. Classification, priority, and sizing from there arebacklog-refinement's call, not something to pre-decide here. - Orphaned scope — an issue or shipped feature that isn't traceable to any PRD requirement. This is quiet product-surface expansion — the thing CLAUDE.md's implementation workflow already warns against. Flag it and ask whether it should be retroactively added to the PRD (it was actually a good, deliberate call) or whether it's scope creep to be aware of going forward.
This is a periodic sweep, not a per-issue reflex — see §10 for the full review cadence this fits into.
4. Acceptance-criteria validation
Every P0 Requirement's _Acceptance:_ clauses are the actual definition of
"done" — a merged PR or a checked checklist box is a proxy for that, not a
substitute. Before treating a requirement as shipped:
- Re-read its
_Acceptance:_clauses verbatim. - Check whether there's test coverage or a manual verification that actually exercises each one — not just that the surrounding feature works in the happy path.
- If a clause isn't demonstrably met, say so plainly rather than deferring to "the PR merged, so it's probably fine" — this is exactly the gap between "the checklist is checked" and "the acceptance criteria are true" this responsibility exists to catch.
5. Non-goal enforcement
The PRD's Non-Goals are deliberate, reasoned exclusions, not just an unprioritized backlog — several are marked explicitly settled (Non-Goal #5, chat/channels: "treat that decision as settled rather than re-opening it from first principles absent genuinely new evidence"). When a proposed feature, issue, or PR touches one of these:
- Name which Non-Goal it touches and quote the PRD's stated reasoning for it.
- Ask: is there genuinely new evidence since the Non-Goal was written, or is this the same case already considered and rejected? "It would be nice" is not new evidence; a changed constraint, a validated user need that didn't exist before, or a technical fact that's since changed is.
- If there's no new evidence, say so directly and don't implement it — the PRD's own language is explicit that revisiting these needs a real reason, not just renewed interest.
- If there genuinely is new evidence, that's a §1 PRD-stewardship edit (update the Non-Goal's own text to reflect the reconsideration), not a silent feature addition.
6. Roadmap sequencing / pull-forward decisions
The PRD already pulls several P1 items into Phase 0 dogfooding (multi-space, saved/embedded views, backlinks, search) because they're direct requirements of the founder's own daily use, even though their formal phase boundary is later — see the note under Phase 2 in Timeline Considerations. Deciding what else gets pulled forward is a judgment call: does not having it block or meaningfully hamper actual daily use right now, or is it a nice-to-have that can wait for its formal phase? When you pull something forward, update the PRD's own phasing language to stay honest about it (§1) rather than letting the phase boundaries silently drift out of sync with what's actually being built.
7. Dogfooding feedback triage
Phase 0's only real validation signal is the founder's own daily use (see Success Metrics). When friction comes up in normal use, triage it three ways:
- Missing P0 requirement — the PRD doesn't ask for this at all, and it's
urgent enough to block or meaningfully hamper daily use right now. That's
a §1 PRD edit (add the requirement, with acceptance criteria), then hand
off to
backlog-refinementto file it. - Missing P1/P2 requirement — the PRD doesn't cover this at all, but it's
not urgent enough to be P0 — a genuinely new requirement, not an existing
one that needs pulling forward. That's still a §1 PRD edit (add it at the
right tier, with acceptance criteria if the tier's convention has them —
see the structure map above), then hand off to
backlog-refinement. - P1/P2 item that should be pulled forward — the PRD already covers this, just at a later phase. That's a §6 call, not a new PRD entry.
- Already-scoped, just needs tracking — the PRD covers it, an issue
already exists or should exist with normal priority. That's purely
backlog-refinement's job — don't duplicate its triage logic here, hand off.
8. Competitive/market assumption re-checks
The PRD's "Competitive context, checked rather than assumed" section already demonstrates the right instinct once: it caught its own stale claim (Gemini/ Copilot now do edit in-place, within their own ecosystem) instead of asserting an unverified one. Periodically — not on every conversation, but when asked to review the PRD or when a claim looks like it's aged — re-verify load-bearing external claims the product thesis depends on, the same way: check before asserting, and if a claim turns out stale, that's a §1 edit with the correction and what changed, not a silent removal.
9. Spec-consistency gate, upstream of writing the spec
CLAUDE.md's implementation workflow already says a missing
docs/specifications/*.md behavior gets written as part of the same change
that needs it. This responsibility is earlier than that: before a spec gets
written (or when reviewing one already drafted), check it against the PRD's
Core Architectural Principle — does the proposed behavior treat Documents
and Collections uniformly, do Views stay non-owning projections rather than
copying data, does each block-record store its rich text in its own
Y.Text with native .format() ranges (per CLAUDE.md) rather than a
single document-wide Y.Text, a Markdown string, or a stored run array —
RichText.runs is derived on read, never stored, and block-level CRDT/hold
granularity depends on the per-record split? Catching an
architecture-violating spec before
it's written is cheaper than catching it in code review, and is exactly the
kind of check that requires having the Core Architectural Principle in mind,
not just the local feature request.
10. Success-metrics readiness
Phase 0 deliberately has no quantitative metrics team — "the founder using the tool daily is the validation" is explicit in the PRD. Don't propose instrumenting the Leading/Lagging Indicators section's metrics (agent action adoption, edit conflict rate, etc.) as a Phase 0 activity; that section itself says these "apply from Phase 1 onward." This responsibility's job is noticing the transition point — when Phase 0's qualitative bar (§2) looks met and it's worth discussing whether real instrumentation is becoming worth building, not building it preemptively.
Periodic product review
The "run this regularly" entry point the sections above feed into — when asked to review the PRD, check roadmap health, or periodically on your own initiative:
- Read
docs/prd.mdin full — it's short enough (~300 lines) that a partial read risks missing a Non-Goal or an already-settled decision. - Sweep Requirements for traceability gaps (§3) — orphaned requirements and orphaned scope.
- Spot-check a few P0 requirements' acceptance criteria against actual current behavior (§4), not just checklist state.
- Ask whether Phase 0's qualitative bar looks met (§2) — surface the question, let the user answer it.
- Note anything that looks like drift: a Non-Goal quietly crossed (§5), a phasing claim in Timeline Considerations that no longer matches what's actually pulled forward (§6), or a competitive claim that's aged (§8).
Summarize as a direct punch list — what's solid, what's drifted, what needs
a decision from the user — the same shape backlog-refinement's grooming
pass uses. Don't silently fix everything found; PRD edits go through the
write-confirmation rule above, and phase-gating and non-goal calls are the
user's to make, not this skill's to decide unilaterally.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

