跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
开发与测试

user-alignment

Use when turning a vague or messy user request into an aligned, agent-executable PRD. Converts raw requests into testable specs with scope, phases, acceptance criteria, and explicit do-not-do boundaries for coding agents. Triggers on planning a feature from a rough ask, writing a PRD/spec, or aligning on intent before code.

tryproduck · 已有 AI 审核记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add tryproduck/produck-skills --skill user-alignment

技能说明


name: user-alignment description: Use when turning a vague or messy user request into an aligned, agent-executable PRD. Converts raw requests into testable specs with scope, phases, acceptance criteria, and explicit do-not-do boundaries for coding agents. Triggers on planning a feature from a rough ask, writing a PRD/spec, or aligning on intent before code. license: Apache-2.0 metadata: author: produck version: "1.0.0"

User Alignment & Agent-Executable PRDs

Purpose: A practical guide for turning messy user requests into aligned, testable Product Requirements Documents (PRDs) that autonomous or semi-autonomous agents can execute without drifting.

Two supporting files ship with this skill:

  • references/prd-template.md — the full copy-paste agent-executable PRD template.
  • references/reading-list.md — the research and reference map this guide is built on.

1. Core thesis

A good agent PRD is not just a product document. It is a shared operating contract between the user, the product owner, and the implementation agent.

It must do three jobs at once:

  1. Align on user intent — what the user actually wants, why it matters, and what outcome would make them say “yes, that’s it.”
  2. Remove ambiguity before execution — especially around scope, constraints, priorities, edge cases, and trade-offs.
  3. Translate intent into executable work — sequenced phases, explicit files/systems, acceptance criteria, tests, and “do not do” boundaries.

For human teams, ambiguity can be resolved in meetings. Agents often resolve ambiguity by guessing. The PRD’s job is to make guessing unnecessary.


2. Research-backed principles

2.1 Start with the user problem, not the implementation

AI/product PRDs should begin with the user pain and the cost of the status quo, not with “we will use AI/model/tool X.” The model, framework, or agent is an implementation detail unless the user explicitly constrained it.

A strong problem statement should include:

  • Who is affected.
  • What they are trying to accomplish.
  • What blocks them today.
  • Why existing/manual/deterministic solutions are insufficient.
  • What measurable improvement would matter.

Bad: “Build an AI assistant for support.”
Better: “Support agents spend 8 minutes triaging each ticket, and 23% are misrouted. We need ticket classification under 2 seconds with at least 92% routing accuracy, while escalating low-confidence cases.”

2.2 Treat the PRD as an executable artifact

Spec-driven development treats the spec as a durable source of truth, not disposable planning scaffolding. The spec should be checked into the repo and referenced by agents across sessions.

The PRD should answer:

  • What should be built?
  • Why does it matter?
  • What is explicitly out of scope?
  • What order should work happen in?
  • How will each phase be verified?
  • What should the agent never touch?

2.3 Write for two audiences: humans first, agents second

The top of the PRD should explain the product and user context in human language. The lower sections should become increasingly operational and literal for the agent.

Recommended split:

Section typeAudienceStyle
Problem, users, goals, success metricsHumans + agentsClear prose, rationale, trade-offs
Scope, constraints, edge casesHumans + agentsStructured bullets/tables
Phases, tasks, tests, commandsAgentsExplicit, sequential, verifiable
“Do not do” instructionsAgentsDirect prohibitions, no nuance

2.4 Break work into bounded phases

Traditional PRDs often describe the whole product and leave sequencing to engineers. Agent PRDs should define implementation phases with dependencies and testable outputs.

Each phase needs:

  • Dependency: what must already exist.
  • Scope: what this phase covers.
  • Out of scope: adjacent work the agent must not do yet.
  • Tasks: concrete implementation actions.
  • Verification: commands, tests, screenshots, or manual checks that prove completion.

2.5 Define evaluation before implementation

For AI or agentic features, “works” is rarely binary. Define launch thresholds, target thresholds, and aspirational thresholds before building.

Include three metric classes:

  1. Outcome metrics — user/business result, e.g. completion rate, time saved, conversion lift.
  2. Quality metrics — correctness, relevance, tone, completeness, usefulness.
  3. Operational metrics — latency, cost, reliability, throughput, escalation rate.

For agent-executed software projects, also define:

  • Unit/integration/e2e tests required.
  • Manual QA checks.
  • Review criteria.
  • Regression risks.
  • Expected screenshots or artifacts.

2.6 Make constraints and prohibitions explicit

Agents overbuild when boundaries are unclear. Every PRD should include an explicit “do not do” section.

Examples:

  • Do not change authentication.
  • Do not modify database schema outside the listed migration.
  • Do not install new dependencies without approval.
  • Do not touch deployment files.
  • Do not redesign unrelated UI.
  • Do not commit secrets.
  • Do not treat P1/P2 items as required for MVP.

2.7 Use semi-formal requirement language when precision matters

For behavioral requirements and acceptance criteria, use a lightweight syntax such as EARS or Given/When/Then.

Useful EARS patterns:

  • WHEN [trigger] THEN [system] SHALL [response]
  • IF [condition] THEN [system] SHALL [response]
  • WHILE [state] [system] SHALL [continuous behavior]
  • WHERE [context] [system] SHALL [contextual behavior]

Useful BDD pattern:

Given [context]
When [user action or system event]
Then [observable result]
And [additional observable result]

Avoid vague terms like “fast,” “simple,” “intuitive,” “robust,” or “user-friendly” unless they are backed by measurable thresholds.

2.8 Ingest User Session Replays &

阅读完整来源 ↗