Product Cabinet

Product Cabinet is a portable skill pack that gives an AI agent the operating model of an accountable product executive. A product-ceo orchestrator selects the minimum sufficient set of product, customer, design, engineering, quality, launch, and governance capabilities for each request.

Product Cabinet is packaged for GitHub Copilot and Claude Code and remains a portable collection of skills rather than a standalone agent runtime. The host decides whether specialist work runs in the current context or in isolated agents.

Requirements

Choose one installation option:

• GitHub Copilot CLI or VS Code with agent-plugin support
• Claude Code with plugin support
• a compatible Agent Skills host that loads skills from a local directory

Product Cabinet works best when the host:

• discovers skills from SKILL.md files
• makes sibling skills available in the same session
• lets a skill read referenced Markdown files in the installed pack
• can delegate bounded work to isolated agents or contexts

Delegation is optional. When isolated agents are unavailable, the Product CEO can apply specialist skills sequentially in the current context, but it must disclose that board and reviewer independence was not available.

Installation

Option 1: GitHub Copilot marketplace

Register the marketplace and install Product Cabinet:

copilot plugin marketplace add willtsai/agentic-skills
copilot plugin install product-cabinet@willtsai-agentic-skills

To browse the marketplace from an interactive Copilot CLI session:

/plugin marketplace browse willtsai-agentic-skills

In VS Code, open the Extensions view and search for @agentPlugins, or run Chat: Plugins from the Command Palette. Product Cabinet appears there after the marketplace is registered.

Restart the Copilot CLI session or reload the VS Code window if the newly installed skills do not appear immediately.

Verify the installation by asking:

Use the product-ceo skill to list the Product Cabinet capabilities and explain
which ones you would use to define a new developer-facing API feature.

Copilot discovers installed skills by their descriptions. Specialist skills can also be requested directly, such as product-specification or quality-review.

Option 2: Claude Code marketplace

Register the marketplace in Claude Code:

/plugin marketplace add willtsai/agentic-skills

Open /plugin, select Browse and install plugins, choose the willtsai-agentic-skills marketplace, select product-cabinet, and confirm the installation scope.

Alternatively, install it directly:

/plugin install product-cabinet@willtsai-agentic-skills

If the installation summary asks you to reload:

/reload-plugins

Verify the installation by running:

/product-cabinet:product-ceo

Then provide a request:

Write a feature specification for organization-level API keys. Select the minimum
sufficient Product Cabinet capabilities, explain the staffing plan, and return one
synthesized recommendation.

You can also invoke specialist skills with the same plugin namespace, such as /product-cabinet:product-specification or /product-cabinet:quality-review.

Option 3: Manual installation

Clone the repository and run the installer for your platform:

git clone https://github.com/willtsai/agentic-skills.git
cd agentic-skills/product-cabinet

On macOS, Linux, or Git Bash:

./install.sh

On Windows PowerShell:

./install.ps1

Both scripts:

• install all ten cabinet skills and the bundled classic-style writing dependency by default
• copy each complete skill directory, including its references and templates
• install to ~/.copilot/skills by default
• refuse to overwrite an existing skill unless explicitly forced
• accept one or more skill names for a partial installation and include classic-style automatically

Install selected skills:

./install.sh product-ceo product-specification quality-review

./install.ps1 product-ceo product-specification quality-review

Replace existing copies during an update:

./install.sh --force

./install.ps1 -Force

Override the destination when your host uses another Agent Skills directory:

COPILOT_SKILLS_DIR="$HOME/custom-skills" ./install.sh

$env:COPILOT_SKILLS_DIR = "$HOME/custom-skills"
./install.ps1

Restart Copilot CLI or reload the agent host after installation.

Selective installations include the bundled writing dependency and its license. If classic-style already exists in your target directory, the installer preserves it unless you pass --force or -Force. Review or back up a customized copy before replacing it; use a separate target directory if you need to retain another version.

Updating or uninstalling

For a marketplace installation, use the host's plugin manager to refresh, update, disable, or uninstall Product Cabinet.

For a manual installation, pull the latest repository changes and rerun the appropriate installer with --force or -Force. To uninstall manually, remove only the Product Cabinet skill directories that were installed under your configured skills directory.

Compatibility notes

Marketplace manifests are host-specific distribution adapters. The skills use portable SKILL.md files. Each skill keeps its references and templates in its own directory, and the installers also include the required classic-style sibling. Do not copy a cabinet skill alone without its writing dependency.

Initial skills

Required writing skill

classic-style is bundled from ryanwaite/copilot-skills. It is a writing dependency, not another cabinet role. Marketplace users receive it with Product Cabinet; there is no second plugin to install or runtime download.

Every cabinet skill uses it when authoring or revising a document, whether invoked directly or through the Product CEO. The workflow is:

1. Draft the document from verified inputs and the role's required structure.
2. Invoke the bundled classic-style with keep my structure; output only.
3. Check the resulting document against its template and substantive requirements.

The pass improves prose without changing claims, citations, uncertainty, decisions, code examples, or required review fields. It must not turn an assumption into a fact. Any writing notes stay in chat; feature specs still contain only the required template sections. Reviews apply the writing pass to their own reports, not to an artifact they have only been asked to review.

In Claude Code, use product-cabinet:classic-style to distinguish the bundled skill from other installed copies. If a host cannot invoke skills directly, the cabinet skill reads the sibling skill and its reference. If the dependency is missing, it reports the problem and asks for installation repair rather than silently skipping the writing pass.

Operating model

1. Invoke product-ceo with a product request.
2. The Product CEO frames the decision or deliverable and evaluates uncertainty, impact, and risk.
3. It selects the minimum sufficient capabilities from the capability catalog.
4. Each specialist receives a bounded delegation contract.
5. The Product CEO reconciles evidence and disagreements into one accountable recommendation.
6. Material decisions receive an independent board-review.
7. The final chat response briefly summarizes material findings and next decisions, separately from the requested artifact.

The Product CEO should apply a skill directly for bounded procedural work and use an isolated agent when work needs substantial separate context, parallel execution, distinct tools, or independent judgment.

Usage

Start with the Product CEO

For cross-functional work, invoke product-ceo and describe the outcome, available context, constraints, and desired artifact. You do not need to select the specialists yourself.

Use the product-ceo skill to define a feature for organization-level API keys.

Our target users are platform administrators at enterprise customers. Produce a
feature specification, identify the minimum sufficient Product Cabinet capabilities,
and call out assumptions that require customer validation. Do not make implementation
decisions that belong in architecture review.

The Product CEO should:

1. frame the decision and completion criteria
2. assess impact, uncertainty, risk, and reversibility
3. present a minimum-sufficient staffing plan
4. invoke or delegate the selected specialist skills
5. reconcile findings and disagreements
6. request quality or board review when warranted
7. return one accountable artifact or recommendation

Provide existing artifacts

Point the Product CEO to specifications, research, designs, repositories, plans, or launch material that should be treated as evidence:

Use the product-ceo skill to assess whether this feature is ready for implementation.

Inputs:
- Feature specification: docs/features/api-keys.md
- Design prototype: <design URL>
- Relevant code: src/auth and src/organizations

Use architecture-review, product-design-review, and quality-review as needed.
Return the decision, blocking findings, owners, and next gate.

The Product CEO must distinguish supplied evidence from assumptions and should not claim to have inspected an artifact the host could not access.

Invoke a specialist directly

Use a specialist without the Product CEO when the task is bounded and does not require cross-functional synthesis:

Use product-specification to turn these discovery findings into a feature spec.
Follow the Product Cabinet feature specification template strictly. Put unsupported
product details in its assumptions/questions section, not a new open-decisions section.

Use developer-experience-review to evaluate this CLI quickstart from installation
through first successful deployment. Identify observed friction separately from
issues inferred through static review.

Use quality-review to assess this implementation plan against the approved feature
specification and architecture. Return PASS, FAIL, or UNVERIFIED with evidence.

Request a board review

Board review is intended for material decisions, not routine product work:

Use product-ceo to prepare a decision on deprecating v1 of our public API.
After the operating review, invoke board-review with independent customer, strategy,
financial, technology, and trust perspectives. Preserve dissent and identify every
condition requiring human approval.

When the host supports isolated agents, each board perspective should be evaluated independently against the same evidence packet. When it does not, the output must be labeled as a structured challenge rather than an independent board review.

Control orchestration explicitly

You can constrain how the cabinet operates:

Use product-ceo for this request.

Constraints:
- Limit the cabinet to customer-discovery, architecture-review, and product-specification.
- Run discovery and architecture independently.
- Do not invoke board-review.
- Stop and ask before making external calls or modifying repository files.

The Product CEO follows explicit user constraints unless they conflict with required safety, policy, or authority boundaries.

Expected output

A feature specification is a concise product document, not a cabinet report:

• Follow the template's heading names, levels, and order, filling placeholders and adjusting numbered scenario/feature entries as needed.
• Describe user stories, journeys, and observable GUI, CLI, declarative-artifact, or general API experiences where relevant.
• Keep product dependencies, risks, and unknowns in the existing template sections.
• Do not add cabinet decisions, staffing, specialist reports, technical evaluations, review verdicts, or extra sections and appendices.

The agent chat response links to the specification or clearly separates an inline document from a short summary of material cabinet findings, unresolved blockers, required approvals, and review limitations. Detailed architecture, delivery plans, or governance reports are separate deliverables only when requested.

The same separation applies whether product-specification is invoked directly or through product-ceo.

Recommended first run

Test the pack with a bounded feature specification before using it for a portfolio or launch decision:

Use the product-ceo skill to write a feature specification for saved dashboard views.

Before drafting:
1. State the decision and known assumptions.
2. Select the minimum sufficient Product Cabinet skills.
3. Explain which skills you will apply directly and which need isolated agents.

Follow the Product Cabinet feature specification template strictly. Focus on user
stories and the observable experience of creating, saving, and reusing a dashboard view.
Put measurable outcomes and open product questions in the relevant existing sections.
Finish with a quality-review; keep its verdict and the cabinet findings in a brief
chat summary, not in the specification.

Skill format

Each skill is stored at skills/<skill-name>/SKILL.md and contains:

• YAML frontmatter with a stable name and discovery description
• skill-local references and templates when needed
• purpose and invocation criteria
• required inputs and outputs
• an execution workflow
• quality requirements
• role boundaries and escalation rules

The instructions avoid runtime-specific APIs. Hosts can map phrases such as "invoke a skill" and "delegate to an isolated agent" to their own orchestration primitives.

Templates

• Feature specification, adapted from the Radius project template
• Board review
• Decision record

Contributing

For dependency updates, validation, and release procedures, see CONTRIBUTING.md. Maintainer builds use the pinned, published Skillpacker npm package; GitHub Actions checks frozen bundles and distribution tests. Manifest-change PRs from this repository also receive generated dependency updates on the same PR branch.

Principles

• Accountability over role-play. The Product CEO owns synthesis and decisions rather than concatenating specialist responses.
• Capabilities over org charts. Select expertise required by the work instead of convening every role.
• Evidence over confidence. Distinguish verified facts, inferences, and assumptions.
• WHAT before HOW. Product intent and user outcomes precede architecture and delivery planning.
• Independent challenge. Reviewers must form opinions before seeing the proposed synthesis when practical.
• Visible uncertainty. Missing evidence and unresolved disagreements remain explicit.
• Human authority. The host's user retains control over consequential, irreversible, regulated, or externally visible actions.