p9

Overview of p9 skill

What p9 is for

p9 is a tech-lead style skill for Agent Orchestration. Instead of writing code directly, the p9 skill turns a project goal into execution prompts for other agents, especially a P8 team. Its core job is delegation: clarify scope, split work, assign responsibilities, and drive delivery through prompts rather than implementation.

Who should use p9

Use p9 if you are coordinating multiple agents, managing a larger feature, or need clean task decomposition before execution starts. It fits users who want a planning-and-orchestration layer above coding agents, not users looking for a code generator.

The real job-to-be-done

The practical value of p9 is reducing chaos when a task is too large for one prompt or one agent. If you need to break a request into parallel tracks, define handoffs, or keep a team aligned on output format and constraints, p9 gives a stronger starting structure than an ordinary “please plan this project” prompt.

What makes p9 different

The differentiator is role discipline. The p9 skill explicitly stays in manager mode: it writes task prompts and coordinates P8 agents, but does not act as the implementation agent itself. That boundary matters because it keeps planning cleaner and makes downstream delegation easier to audit.

What to know before installing

This skill is lightweight in-repo. The visible SKILL.md points to additional protocol documents such as references/p9-protocol.md and references/agent-team.md, but those files are not present in the provided tree snapshot. That means p9 is understandable at a high level, but some execution details may depend on the wider tanweai/pua system and the core /pua skill.

How to Use p9 skill

Install context for p9

The baseline install command used for this repository family is:

npx skills add tanweai/pua --skill p9

Because p9 appears to rely on shared /pua conventions, treat it as part of a broader skill system rather than a fully standalone prompt file.

Read this file first

Start with:

• skills/p9/SKILL.md

Then check the parent repository for shared behavior and any missing protocol files referenced by the skill:

• core /pua skill instructions
• references/p9-protocol.md
• references/agent-team.md

If those supporting files are unavailable in your install context, expect to reconstruct some workflow details manually.

What input p9 needs

p9 works best when you provide orchestration-grade inputs, not just a feature request. Useful inputs include:

• the product or repo goal
• current project state
• team or agent roles available
• constraints such as deadline, stack, risk tolerance, and review standards
• what should be parallelized vs kept sequential
• expected deliverables

Without those details, p9 can still decompose work, but the resulting task prompts will be generic.

Turn a rough goal into a p9-ready request

Weak input:

Build user auth for my app.

Stronger p9 usage:

Use p9 for Agent Orchestration. We need to add email/password auth to a Next.js app with Prisma and PostgreSQL. We have 3 implementation agents available. Split work into parallel tracks where safe, define dependencies, create task prompts for each agent, and include acceptance criteria, shared constraints, and integration checkpoints.

The second version gives p9 enough structure to assign work instead of just restating the feature.

What p9 should produce

A good p9 output should include:

• a scoped objective
• task decomposition
• role or agent assignment
• prompt-ready instructions for each downstream agent
• constraints and quality bars
• checkpoints for integration

The source explicitly mentions “Task Prompts” and “P8 team delivery,” so judge success by whether p9 creates executable prompts for others, not by whether it solves the task itself.

Best workflow for p9 usage

A practical workflow is:

1. Give p9 the project objective and operating constraints.
2. Ask it to identify workstreams and dependencies.
3. Have it draft agent-specific task prompts.
4. Review for missing acceptance criteria, ownership gaps, or integration risks.
5. Send those prompts to coding agents such as P8-style executors.
6. Bring results back to p9 for reconciliation, reprioritization, or next-step planning.

This is where p9 is stronger than a generic planning prompt: it is meant to sit above execution agents.

When to invoke p9 instead of a coding skill

Use p9 when:

• the work spans multiple files or systems
• you need several agents in parallel
• handoffs matter
• the project needs sequencing and oversight
• the main problem is ambiguity, coordination, or prompt design

Do not use p9 when you just want one agent to write a small patch quickly.

Practical prompt pattern for p9 skill

A reliable template is:

Use p9 skill as tech lead. Do not write code. Break this goal into agent-executable task prompts for a P8 team. Include scope, owner, inputs, outputs, constraints, dependencies, and acceptance criteria. Goal: ... Context: ... Available agents: ... Constraints: ... Done means: ...

This prompt reinforces the core behavior documented in SKILL.md: manager mode, prompt-writing, and no direct coding.

Boundaries that affect adoption

The main adoption caveat is hidden protocol dependency. SKILL.md references external documents and a core /pua behavior model, including “three red lines” and a narration protocol, but those details are not exposed here. If your platform only imports the single skill file, you may need to define your own operating rules for delegation quality, escalation, and safety.

What to check after the first run

After p9 generates a plan, verify:

• each task has a clear owner
• dependencies are explicit
• shared constraints are repeated across sub-prompts
• integration and testing are not orphaned
• no task accidentally asks p9 to code

These checks materially improve output quality because orchestration failures usually come from vague handoffs, not from bad high-level planning.

p9 skill FAQ

Is p9 a coding skill?

No. The p9 skill is explicitly positioned as a manager or tech-lead mode. It writes prompts and manages a P8 team rather than implementing code itself.

Is p9 good for beginners?

Yes, if your problem is coordination rather than coding syntax. But beginners should know that p9 is not a shortcut to implementation. You still need downstream agents or your own execution workflow.

When is p9 better than a normal planning prompt?

p9 is better when you want reusable task prompts, role separation, and multi-agent coordination. A normal prompt may give a plan; p9 is aimed at producing delegated execution units.

When should I not use p9?

Skip p9 for small, self-contained tasks, urgent one-file fixes, or situations where one strong coding agent can complete the work faster than a manager layer can organize it.

Does p9 work outside the PUA ecosystem?

Partially. The high-level orchestration idea is portable, but the skill appears designed around P8 agents and /pua core rules. Expect some adaptation if you use a different agent stack.

What does “p9 for Agent Orchestration” really mean?

It means p9 is most useful as a coordination layer above execution agents. Its value is not raw generation power; its value is creating clearer prompts, cleaner division of labor, and more controlled multi-agent delivery.

How to Improve p9 skill

Give p9 decision-grade context

The fastest way to improve p9 output is to provide the management context a tech lead would ask for: scope, risks, architecture, available agents, deadlines, and non-negotiable constraints. p9 gets stronger as the coordination problem becomes more concrete.

Ask for explicit task prompt fields

If the first output feels loose, request a fixed schema for every delegated task, such as:

• objective
• owner
• inputs
• required files
• implementation constraints
• deliverable
• acceptance criteria
• dependency notes

This turns p9 from “planner” into “prompt packager.”

Prevent the main failure mode

The most common failure mode is shallow decomposition: tasks sound organized but are not executable. To avoid this, ask p9 to make each task independently actionable by another agent without extra clarification.

Improve p9 usage with better constraints

Useful constraints to add:

• stack and framework versions
• files or directories in scope
• coding standards
• test expectations
• review gates
• what must not change

These details reduce rework when downstream agents interpret prompts differently.

Iterate on integration, not just decomposition

After p9 creates task prompts, ask a second-pass question:

Review this plan for integration risk, duplicated work, hidden dependencies, and missing validation steps.

This often improves real delivery more than asking for finer decomposition.

Adapt p9 if supporting references are missing

If the referenced protocol files are unavailable, define your own local rules before using p9 at scale:

• p9 never writes production code
• every delegated task must include acceptance criteria
• one task owns integration
• one task owns verification
• unresolved dependencies must be surfaced early

That adaptation makes the p9 skill more usable even without the full repository context.