> ## Documentation Index > Fetch the complete documentation index at: https://docs.dotready.org/llms.txt > Use this file to discover all available pages before exploring further. # Ready Product Leader Skill Pack for AI Agents Guide > The Ready Product Leader Skill Pack gives AI agents a portable, versioned set of instructions for creating and refining Ready product trees. The Ready Product Leader Skill Pack is a portable collection of AI agent instructions you copy into any project to give agents everything they need to create or revise a Ready product tree. It ships as plain text files you can read, version, and modify — no binary archive required. The current release is **version 0.3.2**, package id `ready-product-leader`. ## What the skill pack does The skill pack is an orchestration layer. The entrypoint (`skills/ready-skill.md`) acts as a router: it reads the situation, decides which specialist work is needed, and loads the right modules. Each module handles a focused domain — evidence, access, design, coding handoff, or perspective review — so agents load only what the task actually requires. The skill does not prescribe internal code structure. Its job is to ensure coding agents know exactly what product outcome to build and have the evidence, access, designs, and proof policy to do it without avoidable blockers. ## Package structure ```text theme={null} skills/ README.md manifest.yaml ready-skill.md modules/ evidence-resource-review.md access-readiness.md design-artifact-readiness.md coding-handoff-readiness.md perspective-review.md ``` | File | Role | | ----------------------- | ------------------------------------------------------------------- | | `skills/ready-skill.md` | Entrypoint — routes work, owns product-leadership stance | | `skills/modules/*.md` | Specialist modules — load on demand for focused task procedure | | `skills/manifest.yaml` | Package manifest — lists all portable files, load order, module ids | ## How to use the skill pack Load the skill pack in the correct order. The `load_order` in `manifest.yaml` specifies: 1. `ready/governance/product-orchestrator-charter.md` — load your project's orchestrator charter first so the agent has authority context before doing any work. 2. `skills/ready-skill.md` — load the skill entrypoint second; from here the agent routes to specialist modules as gaps appear. You do not need to pre-load all five modules. The entrypoint directs the agent to load each module when the relevant gap arises. ## How to copy the skill pack into a project Copy the files listed under `portable_files` in `manifest.yaml` as source text into the receiving project. Then: 1. Register the copied files in the project's standard-resource manifest. 2. Record loaded file hashes in agent context manifests when running product agents. 3. Treat the copied files as reviewable, versionable product resources — not locked binaries. Do not copy project-specific secrets, local cache, raw logs, or private sample data alongside the skill pack. Those are project artifacts, not portable standard resources. ## Package manifest reference ```yaml theme={null} schema: "readyroom/skill-package/v1" package_id: "ready-product-leader" package_name: "Ready Product Leader Skill Pack" version: "0.3.2" entrypoint: "skills/ready-skill.md" package_root: "skills" copy_root: "skills" description: "Portable Ready Skill entrypoint and task modules for creating product trees that coding agents can build from." load_order: - "ready/governance/product-orchestrator-charter.md" - "skills/ready-skill.md" modules: - id: "ready-evidence-resource-review" path: "skills/modules/evidence-resource-review.md" load_when: "Evidence, samples, generated fixtures, public resources, or user-only information are missing or unverified." - id: "ready-access-readiness" path: "skills/modules/access-readiness.md" load_when: "Accounts, credentials, environments, CLI logins, provider sessions, or service setup can block coding." - id: "ready-design-artifact-readiness" path: "skills/modules/design-artifact-readiness.md" load_when: "UI, workflow, copy, visual proof, component contracts, or design handoff can affect implementation." - id: "ready-coding-handoff-readiness" path: "skills/modules/coding-handoff-readiness.md" load_when: "A seed or delta flag may become claimable or a coding agent needs a work package." - id: "ready-perspective-review" path: "skills/modules/perspective-review.md" load_when: "The tree needs psychological, physical, logical, evidence, design, or access challenge review." portable_files: - "skills/README.md" - "skills/manifest.yaml" - "skills/ready-skill.md" - "skills/modules/evidence-resource-review.md" - "skills/modules/access-readiness.md" - "skills/modules/design-artifact-readiness.md" - "skills/modules/coding-handoff-readiness.md" - "skills/modules/perspective-review.md" worker_output_contract: - "findings" - "evidence_refs" - "proposed_primitive_or_flag_edits" - "uncertainty" - "user_only_asks" - "safe_agent_gatherable_resources" - "readiness_recommendation" rules: - "The entrypoint routes work; modules provide task procedure." - "Copy the package as source text, not as a binary archive, unless the receiving project explicitly wants an archive." - "Do not copy project-specific secrets, local cache, raw logs, or private sample data with the skill pack." - "Receiving projects should add copied files to their own standard-resource manifest and record loaded file hashes in agent context manifests." ``` ## Input modes The entrypoint supports three starting points for building a Ready tree. Use this mode when the project has planning docs, specs, strategy prose, design docs, or issue lists but no reliable codebase signal. The agent inventories the docs, extracts premise and intent candidates, identifies missing evidence and resources, preserves conflicts rather than averaging them, and creates draft primitives with evidence confidence markers. Facts are labelled as user-stated, doc-stated, inferred, stale, generated, or unresolved. Use this mode when the project has code but little or no reliable product documentation. The agent inspects visible product surfaces (routes, APIs, schemas, tests, fixtures, configuration), infers current behavior, and separates that from approved direction. User problems and product motivations remain lower confidence until confirmed. Codebase-only trees are conservative by design. Use this mode when the product is being discovered in conversation. The agent asks product-leader questions — starting broad, becoming concrete — to identify the user, problem, solution candidates, and next stage. It shapes the smallest useful stage, then builds the Ready tree and reviews it with you. ## Product-leadership stance The skill embodies a specific product-leadership philosophy baked into `ready-skill.md`: * **Start with the user's problem.** Premises before solutions, problems before technology choices. * **Separate evidence from truth.** Docs, code, chat, and generated output are evidence. They become approved product truth only when committed to the tree. * **Preserve uncertainty.** Use question cards, draft fields, low-confidence flags, and blocked states rather than guessing. * **Prefer a smaller next stage.** Cut nice-to-have work until it clearly supports the next stage's core promise. * **Keep implementation details out of primitives** unless they are genuine product constraints, interfaces, standards, artifacts, services, or proof expectations. ## Worker output contract Every module and subagent returns the same set of fields so orchestration is predictable. | Field | What it contains | | ---------------------------------- | ----------------------------------------------------------- | | `findings` | What the agent discovered about the current state | | `evidence_refs` | Sources, artifacts, or primitives that support the findings | | `proposed_primitive_or_flag_edits` | Specific edits to make to the tree | | `uncertainty` | What remains unresolved or low-confidence | | `user_only_asks` | Information only the user can provide | | `safe_agent_gatherable_resources` | What the agent can gather safely without user involvement | | `readiness_recommendation` | `ready`, `draft`, `blocked`, or `cut` | ## Skill modules Each module covers a specialist domain. Load them based on gaps, not ceremony. Verify evidence, evaluate sample data, gather public resources, and create precise user-only asks when private data is needed. Identify every service, account, and credential needed; record safe references; create blocked flags when access is missing. Ensure mockups, flows, copy, states, assets, and component contracts exist before implementation begins. Convert product truth into coding-agent-ready work packages with scope, proof, services, and blocker policy. Challenge the tree from psychological, physical, logical, evidence, design, and access perspectives before handoff.