agentleFS
bryliebrylie/compendium/.claude/skills/product-owner/SKILL.md

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

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
  1. Very specific:

    Read the Timeline Considerations section's definition of what the _next_ phase actually adds (Phase 1 = multi-human collaboration + auth.

    line 86
  2. Distinctive:

    Check whether Phase 0's qualitative bar is actually met — this requires asking the user directly, since only they know whether they're …

    line 89
  3. Very specific:

    Every Requirement bullet (P0/P1/P2) should map to a filed issue, or be identifiably already done.

    line 104
  4. Very specific:

    Every P0 Requirement's _Acceptance:_ clauses are the actual definition of "done" — a merged PR or a checked checklist box is a proxy for …

    line 125
  5. Distinctive:

    Check whether there's test coverage or a manual verification that actually exercises each one — not just that the surrounding feature works …

    line 130
  6. Distinctive:

    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 …

    line 133
  7. Distinctive:

    Ask: is there genuinely new evidence since the Non-Goal was written, or is this the same case already considered and rejected?

    line 148
  8. Distinctive:

    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 …

    line 152
  9. Distinctive:

    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 …

    line 155
  10. Very specific:

    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.

    line 240
  11. Distinctive:

    Ask whether Phase 0's qualitative bar looks met (§2) — surface the question, let the user answer it.

    line 246

“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.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

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:

SectionWhat it's for
Problem StatementThe thesis this whole project is betting on
Goals / Non-GoalsWhat's in scope and — just as load-bearing — what's deliberately excluded and why
Target UsersPersonas; note Phase 0 collapses several personas onto one person
User StoriesPer-persona scenarios; the concrete cases Requirements exist to satisfy
Core Architectural PrincipleThe unified record/Document/Collection/View model — the thing a new spec must not violate
RequirementsMust-Have (P0) / Nice-to-Have (P1) / Future Considerations (P2) — only P0 items carry explicit _Acceptance:_ clauses today
Success MetricsLeading/lagging indicators — explicitly Phase 1+ only; Phase 0's bar is qualitative
Open QuestionsCurrently empty ("ready to move into engineering scoping") — don't treat this as invalid just because it's short
Timeline ConsiderationsThe 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:

  1. 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).
  2. 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.
  3. 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-refinement with 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 are backlog-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:

  1. Re-read its _Acceptance:_ clauses verbatim.
  2. 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.
  3. 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:

  1. Name which Non-Goal it touches and quote the PRD's stated reasoning for it.
  2. 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.
  3. 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.
  4. 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-refinement to 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:

  1. 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.
  2. Sweep Requirements for traceability gaps (§3) — orphaned requirements and orphaned scope.
  3. Spot-check a few P0 requirements' acceptance criteria against actual current behavior (§4), not just checklist state.
  4. Ask whether Phase 0's qualitative bar looks met (§2) — surface the question, let the user answer it.
  5. 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.

Download now (ZIP)

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
What did you use it for? e.g. Reviewing pull requests in a Rails app

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.