A custom product skill turns a checklist you repeatedly explain into a reusable method. In 1PC, you create or import the instructions on use1pc, publish a private version, then ask Product Owner to apply it using your saved product context.

This tutorial uses a small launch-review checklist. It is original teaching material. Every 1PC User can author and publish private skills; execution uses a connected client and prepaid MCP credit.

Choose a method worth repeating

Good candidates have a clear trigger and an assessable result: reviewing a launch claim, checking a content brief or running your weekly product review. Start with one task you already know how to judge.

Keep changing product facts in product knowledge and the repeatable assessment method in the skill. Your audience, current price and released features may change between reviews; the skill should read the relevant current records rather than embed stale claims.

Separate the method from the product it reviews
Keep in the skillRead from product context
Check who the launch message is for.The current accepted customer and positioning.
Classify claims as supported, planned or unknown.The feature scope, actual delivery checks and evidence.
Identify a bounded next correction.The founder's capacity and unfinished launch work.

If your facts are still scattered, bring the existing product into 1PC first. A reusable method becomes useful when it has current information to work on.

Write a small launch-review SKILL.md

SKILL.md uses name/description metadata followed by Markdown instructions, as described in the Agent Skills specification. The example below fits 1PC's text import. Copy it into a UTF-8 file named SKILL.md, or use its body in the draft editor.

---
name: launch-review
description: Review a feature launch brief against current customer context and supported product behavior. Use before finalizing launch messaging.
---

# Launch review

Read the selected product's current overview, messaging and feature scope.
Identify the requested review goal and the records available as evidence.

For each material claim:
- Identify the customer situation and the promised result.
- Compare it with the accepted scope and actual checks supplied.
- Classify it as supported, planned or unknown, with a source reference.
- Explain any mismatch and propose the smallest useful wording correction.

Recommend one next action that fits the founder's available capacity.
Keep missing evidence explicit and proposed choices separate from acceptance.

Deliver a review with claims, sources, corrections and open questions.
Save only within the requested scope and explicit document role.
Do not treat reviewing a launch as permission to publish or send outreach.

The description tells Product Owner when the method applies. The body tells it how to assess the result. Keep both specific enough that this skill can be distinguished from a campaign planner or an interface-copy review.

Create the draft and choose its result

Open Settings → Skills on use1pc. Create a new skill or import the file above. Give it the display title Launch Review and a “When to use” description such as “Use when I ask to check a feature launch brief before finalizing its message.”

Related skill is optional metadata for finding relevant expertise. The selected Task supplies its pinned inputs, required outputs and acceptance checks.

Open Input and output hints and describe the information this method needs and produces. Hints are plain text; they do not select storage paths or create records.

Input hints:
Pinned feature behavior and scope
Current messaging references
Observed delivery evidence

Output hints:
A launch review with sources, corrections and open questions

Completion criteria:
The review distinguishes supported, planned and unknown claims,
identifies sources and corrections, and states a bounded next action.
When saving is requested, the scoped review is saved and read back.

Product Owner should report missing inputs instead of inventing their content. Choose the authorized Product, Feature, Version or Task scope, department, document role and stable key for an actual save.

Importing brings in the text instructions and name/description. Configure the optional related skill, hints and completion criteria separately. 1PC accepts a text SKILL.md file up to 64 KiB; it does not import an executable package, attached scripts or remote includes.

Preview, publish and try the selected version

Save the draft and inspect the preview. Publish a version when the method is ready. Drafts stay out of skill discovery; changing the draft does not change the published instructions being used for new work.

In your connected chat, make the skill choice and desired result explicit:

@1pc Use my published Launch Review skill for this product.
Read the current overview, messaging, accepted feature scope
and relevant delivery evidence. Tell me what context is missing.

Review the claims, propose corrections and one next action.
Save the review as scoped Knowledge using the agreed department,
reference role and stable key. Prepare and self-review the update,
commit its exact revision, then read back the saved receipt.
Keep the review separate from accepting a new product decision.

Product Owner checks saved state, discovers the available private skill and loads the selected published version. If the requested skill is missing or unavailable, it should explain what is needed instead of claiming it ran or silently substituting a built-in method.

Use a few realistic cases to assess the method: a supported claim, a planned feature described as released and a claim with missing evidence. Check the actual saved review, not only whether the chat sounds convincing. The feature-launch guide provides a fictional brief you can adapt.

Improve the method without losing the working version

Edit the draft after a real review exposes a weakness. Publish a new version when the change is ready. Version history lets you restore an earlier revision to a draft; publishing that draft creates another version. Archiving removes a skill from new discovery while keeping its history.

Your private skill library belongs to your workspace. Membership of a shared Product does not share private skills. Each caller uses their own library on accessible Products.

Your authored skills can be exported. Built-in skills show their purpose and available inputs/outputs on the website, with no source export or cloning. If you downgrade, your custom skills remain readable and exportable, while editing, publishing and loading them for execution require paid access.

Carry the result into the next product task

The skill supplies the method; the saved review supplies the continuation. In a fresh conversation, ask Product Owner to read the review and open next steps. Only saved information carries forward, not every explanation from the previous chat.

For example, a claim correction may lead to a landing-page update; an evidence gap may lead to a customer question before more marketing work. Your checklist should help select that next action using the current product state.

If you are choosing where to maintain context, see the Markdown-files versus MCP-workspace comparison. For the broader lifecycle, return to the ChatGPT-for-founders workflow. Start with one method, publish a useful version and evaluate its actual result before expanding the library.

Bring your own product method into the workflow.

Create and publish your method in Settings → Skills. Private skills belong to your workspace and use prepaid MCP credit when loaded.

Connect and set up a private skill ↗