# Hodios paste pack: Product (engineering)
Everything in Product (engineering) from Hodios, the open prompt library by Hermes IDE: 6 entries, catalog 2026.1003.0.
Every entry is dedicated to the public domain under CC0 1.0. Copy, change and share them freely, no attribution needed.
Browse and search the library at https://hermes-ide.com/prompts
## How to use
Find an entry below and copy the text inside its block into ChatGPT, claude.ai or any chat. Replace each [PLACEHOLDER] with your own material. Personas, rules and styles work best as custom instructions or project instructions.
## Contents
- Product (engineering)
- [Define non-functional requirements](#define-non-functional-requirements) (prompt)
- [Product manager](#product-manager) (persona)
- [Refine a backlog ticket](#refine-backlog-ticket) (prompt)
- [Write a PRD](#write-prd) (prompt)
- [Write acceptance criteria](#write-acceptance-criteria) (prompt)
- [Write user stories](#write-user-stories) (prompt)
---
## Define non-functional requirements
`define-non-functional-requirements` · prompt · Product (engineering) · https://hermes-ide.com/prompts/define-non-functional-requirements
Writes measurable non-functional requirements for a feature, covering availability, latency, throughput, security, privacy, accessibility and operability, each with a target, verification and cost.
````markdown
Non-functional requirements are where specs are vaguest and where systems most often disappoint: "fast", "secure", "highly available" and "scalable" cannot be built, tested or traded off. A useful requirement names the quality, the scope it applies to, a measurable target with the percentile or window, how it will be verified, and what it costs. Targets also have to be consistent with the dependencies: a feature cannot be more available than the services it calls synchronously, and every extra nine roughly multiplies effort.
Write the non-functional requirements for:
[FEATURE]
1. Identify the user journeys and operations that matter most and the quality attributes relevant to them. Consider availability, latency, throughput and capacity, scalability, durability and data retention, recovery (RPO and RTO), security, privacy, accessibility, compatibility (browsers, devices, OS versions, API versions), operability (observability, deployability, rollback), maintainability and cost. Skip attributes that truly do not apply and say why in one line.
2. For each requirement write:
- an id (NFR-01, NFR-02…) and the attribute;
- the scope: which operation, journey or component;
- a measurable target with its unit, percentile and window, for example "p95 under 300 ms for search requests measured at the load balancer over 28 days", "99.9% of checkout requests succeed per 30 days", "WCAG 2.2 AA for all customer-facing screens";
- the verification method: load test, synthetic check, SLO dashboard, security review or penetration test, accessibility audit, restore drill, or contract test;
- the rationale, tied to users, the business or a regulation;
- the cost or design implication of meeting it.
3. Check consistency: compare availability and latency targets with the dependencies' targets, show the arithmetic for serial dependencies, and flag targets that are not achievable as stated.
4. For regulatory items, state what the regulation typically requires as a requirement to confirm with the compliance or legal owner, not as legal advice.
5. Propose a sensible target where the input gives none, mark it as proposed, and give the cheaper and the stricter alternative so the owner can choose.
- Every requirement must be testable. Replace words such as fast, secure, scalable, robust and user-friendly with numbers or named standards.
- Do not invent current performance figures, user counts or dependency SLOs. Mark every number that was not given as proposed or assumed.
- Prefer a few requirements that matter over an exhaustive checklist; at most about 15.
- Separate what you verified from what you inferred. Mark inferences as such.
- When you do not know, say "I don't know" once and state what would settle it.
## Summary
The three to five requirements that will most shape the design, in one line each.
## Requirements
Table: id, attribute, scope, target, verification, rationale, status (given, proposed or assumed).
## Trade-offs and cost
Bullets: what meeting the stricter targets would require, and the consistency checks against dependencies with arithmetic.
## Not specified on purpose
Attributes left out and why.
## Open questions
Numbered, each with who should answer it.
````
---
## Product manager
`product-manager` · persona · Product (engineering) · https://hermes-ide.com/prompts/product-manager
Acts as a product manager who starts from the user problem and evidence, writes requirements engineers can build and test, and cuts scope to the smallest valuable release.
````markdown
From now on, work as this persona: Product manager.
You are a product manager who works closely with an engineering team. You care about shipping the smallest thing that solves a real problem for a specific user, and about knowing afterwards whether it did.
How you work:
- Start from the problem, not the solution. For any request, establish who has the problem, how often it happens, what they do today instead, and what evidence shows it matters. When a request arrives as a solution ("add a button that …"), work back to the problem it is meant to solve.
- Keep facts, assumptions and opinions apart, and label each. An assumption that the plan depends on becomes something to validate, not something to build on silently.
- Define success before scope: the outcome you expect, the metric that shows it, its current baseline (or a TODO to measure it) and a target.
- Write requirements engineers can build and testers can verify: specific behaviour, edge cases, error states, permissions and empty states. Say what and why; leave how to the engineers unless there is a real constraint.
- Cut scope deliberately. Separate must-have from nice-to-have, and propose the release that delivers most of the value soonest.
- Bring engineers in early on feasibility and cost, and change the plan when they find a cheaper way to the same outcome.
What you flag:
- Solutions dressed up as requirements, and requirements nobody can test.
- Missing non-goals, unmeasurable success criteria, and metrics with no baseline.
- Unvalidated assumptions about users, and user quotes or data that nobody has a source for.
- Forgotten cases: existing users and their data, permissions and roles, failure and empty states, accessibility, localisation, and what happens to support.
- Scope creep: work that does not serve the stated outcome.
Your habits:
- You never invent research, user quotes, market sizes or metric values. You mark the gap and say how to fill it.
- You write short, plain documents with headings people can scan, and you put decisions and open questions where they cannot be missed.
- You end with the next decision to make and who should make it.
````
---
## Refine a backlog ticket
`refine-backlog-ticket` · prompt · Product (engineering) · https://hermes-ide.com/prompts/refine-backlog-ticket
Turns a vague ticket into a ready-for-development one with the user problem, scope and non-scope, open questions, acceptance criteria and a definition-of-ready check. Use in backlog refinement.
````markdown
A ticket is ready when an engineer who was not in the conversation can build it, a tester can verify it and nobody needs to ask the author what they meant. Vague tickets ("improve search", "users should be able to export") cost more in mid-sprint questions, rework and scope creep than the hour it takes to refine them. Refinement should surface decisions, not paper over them: when the ticket does not say something, the right output is a question with a proposed default, not an invented requirement.
Refine this ticket so it can pass the team's definition of ready.
[TICKET]
If no definition of ready was given, use: the user problem is clear; scope and non-scope are written; acceptance criteria are testable; dependencies are known; designs or examples are attached where UI changes; open questions are answered or have an owner; it is small enough to finish in one sprint.
1. Identify the type (feature, bug, chore, spike) and restate the user problem: who is affected, what they are trying to do, what goes wrong today, and why it matters now. For a bug, include steps to reproduce, expected and actual behaviour, and environment, marking anything missing.
2. Write the scope as concrete behaviours, and the non-scope as the nearby things a reader might assume are included.
3. Write acceptance criteria in Given, When, Then form (or a checklist if that suits the ticket better), covering the main path, the main alternative paths, validation and error cases, empty states, permissions and any edge case the ticket hints at. Each criterion must be checkable by someone who did not write it.
4. List open questions. For each, say why it matters (what it changes in the build or the estimate), propose a default answer, and name who should decide.
5. Note dependencies, risks and anything engineering should know: affected areas, data or migration impact, analytics events to add, documentation or support changes.
6. Check the result against the definition of ready, item by item: met, not met (and what is missing), or not applicable.
7. If the ticket is too large for one sprint or mixes independent outcomes, propose a split into vertical slices that each deliver value on their own.
- Do not invent business rules, numbers, designs or decisions. Anything not in the ticket or context becomes an open question with a proposed default, clearly labelled.
- Keep the original intent. If you think the ticket is solving the wrong problem, say so in one line under Open questions rather than rewriting it into a different ticket.
- Write in plain language a new team member could follow. No filler.
## Refined ticket
**Title:** a short, specific title.
**Type:**
**Problem:** two to four sentences.
**Scope:** bullets.
**Out of scope:** bullets.
**Acceptance criteria:** numbered.
**Notes for engineering:** dependencies, risks, analytics, docs.
## Open questions
Table: question, why it matters, proposed default, who decides.
## Definition-of-ready check
Table: item, status (met, not met, n/a), what is missing.
## Suggested split
Numbered slices, or "Not needed".
````
---
## Write a PRD
`write-prd` · prompt · Product (engineering) · https://hermes-ide.com/prompts/write-prd
Writes a product requirements document that an engineering team can build from, with the problem, goals, success metrics, testable requirements, edge cases and open questions.
````markdown
A PRD aligns product, design and engineering on what to build and why, before the expensive work starts. Engineers use it to find edge cases and push back on scope; testers use it to know what "done" means. It is only as trustworthy as its evidence, so gaps must be visible rather than papered over.
Write a full PRD for: [IDEA]
1. Problem: who has it, when it happens, what they do today, and the evidence that it matters, using only the material given.
2. Goals and non-goals: the outcomes this release must achieve, and things it deliberately will not do.
3. Success metrics: for each, the metric, its current baseline, the target, and how it will be measured. Include one guardrail metric that must not get worse.
4. Users and use cases: the specific user types and the main scenarios, written as short flows.
5. Requirements: numbered, each one testable, each with a priority (must, should, could). Add non-functional requirements (performance, security, privacy, accessibility, localisation) only where they apply.
6. Edge cases: empty states, errors, permissions and roles, limits, existing users and data, concurrent edits.
7. Risks and dependencies, a rollout plan (flag, beta group, migration of existing data, how to roll back), and open questions with an owner where one is known.
For a one-pager, keep Problem, Goals and non-goals, Success metrics, the must-have requirements and Open questions, in under 500 words.
- Describe what and why, not how. Mention implementation only when it is a real constraint.
- Never invent research, user quotes, numbers, dates or names. Write `TODO: …` with what is needed, and repeat important gaps under Open questions.
- Mark assumptions with "Assumption:" so reviewers can challenge them.
- Use plain language a new engineer understands. No marketing tone.
- Separate what you verified from what you inferred. Mark inferences as such.
- When you do not know, say "I don't know" once and state what would settle it.
# [Feature name]
A status line: Draft · Owner: [TODO unless given] · Last updated: [TODO unless known].
Then the sections in this order, each as `##`: Problem, Goals and non-goals, Success metrics (as a table: metric, baseline, target, how measured), Users and use cases, Requirements (as a table: id, requirement, priority), Edge cases, Risks and dependencies, Rollout, Open questions.
For a one-pager, include only the sections named in the task.
````
---
## Write acceptance criteria
`write-acceptance-criteria` · prompt · Product (engineering) · https://hermes-ide.com/prompts/write-acceptance-criteria
Writes testable acceptance criteria for a user story or ticket, covering the main path, alternatives, validation, boundaries, permissions and empty states. Use before a story enters development.
````markdown
Acceptance criteria are the shared definition of done between product, engineering and testing. Good criteria describe observable behaviour with concrete values, so two people reading them would test the same thing. Most production bugs in new features sit in the cases the criteria never mentioned: boundaries, permissions, errors and empty states.
Write acceptance criteria for this story: [STORY]
Style: gherkin.
1. Identify the main path and write it first.
2. Add the cases that apply to this story: alternative paths, input validation, exact boundaries (at, just below and just above each limit), permissions for each role, empty and first-use states, errors from dependencies, and repeated or concurrent actions.
3. Use concrete example values in every criterion (amounts, dates, names, counts), not "valid input".
4. Check every criterion: could a tester verify it with no further explanation? Rewrite any that fail.
- Describe behaviour the user or a system can observe, not implementation or UI layout, unless the story is about the layout.
- Each scenario stands alone and tests one behaviour.
- At most 12 criteria. If the story needs more, say that it should be split and suggest where.
- Do not invent business rules. If a criterion needs a rule that was not given, write it with your best guess, mark it "Assumption:", and repeat it under Questions for the product owner.
## Acceptance criteria
For gherkin: numbered scenarios, each with a `Scenario:` title and Given, When, Then lines (And where needed).
For checklist: numbered "- [ ]" items, one verifiable statement each.
## Assumptions
Bullets, or "None".
## Questions for the product owner
Numbered, or "None".
````
---
## Write user stories
`write-user-stories` · prompt · Product (engineering) · https://hermes-ide.com/prompts/write-user-stories
Turns a feature description into small, independent user stories for specific users, each with acceptance criteria, and splits stories that are too big. Use when preparing a backlog.
````markdown
A user story is a small promise of value to a specific user, sized to finish in a few days and testable on its own. Stories go wrong when they describe technical tasks ("create the table"), when the user is a vague "user", or when one story hides a whole feature.
Write user stories for: [FEATURE]
Format: connextra.
1. Identify the user types and the journey they go through for this feature. Group the stories by journey step.
2. Write one story per piece of user-visible value. Each must be independent, negotiable, valuable, estimable, small and testable (INVEST).
3. Split any story that is too big, using the pattern that fits: workflow steps, business rule variations, data variations, happy path before error paths, simple before complex, or one operation at a time. Note which pattern you used.
4. Under each story, write 2 to 5 acceptance criteria as Given/When/Then, with concrete example values, covering the main path and the most likely failure.
- Name a specific user type in every story. Use "user" only if there truly is a single kind of user.
- No technical tasks as stories. If technical work is needed, mention it in the story's notes.
- Do not invent business rules (limits, prices, permissions). Turn each one you need into an open question.
- At most 15 stories. If the feature needs more, cover the first release and list the rest under Out of scope.
## Stories
For each journey step, a `###` heading, then per story:
**[ID] [Short title]**
The story sentence.
Acceptance criteria (when requested), then Notes if any.
## Split notes
Which stories you split and the pattern used.
## Open questions
Numbered.
## Out of scope
Bullets.
````