🎯 The Product Manager Skill — SkillBar × OpenClaw

Give your digital employee the skills of a $150K/year product manager — for a fraction of the cost.

Who Is This For?

🏪 Small & Medium Business Owner

You don't have a product manager. You don't need one full-time. But every time you tell a developer "build X" and the ticket says three words, you're paying for two rounds of clarification before work even starts. This skill turns your digital employee into the PM you can't justify hiring — it writes complete, structured tickets with research, acceptance criteria, and cost estimates so your devs can start building immediately. You stop paying for misunderstandings.

🚀 Tech Startup

Your backlog is a graveyard of one-line tickets nobody can action. Half your sprint planning is spent deciphering what tickets actually mean. Your engineers resent writing requirements. This skill enforces consistent, high-quality ticket structure across every ticket type — features, bugs, tasks — without anyone thinking about templates. It searches X, Discord, Reddit, and GitHub for patterns before your team reinvents them. Your velocity increases because your tickets stop being bottlenecks.

🏢 Enterprise CTO

You need governance, auditability, and security before anything touches your workflow. This skill runs a deterministic state machine with enforced transitions — no ticket is created without passing through research, structured assembly, and human approval. Every external snippet is sanitized through a 15-pattern token redaction pipeline. Credentials are injected at runtime via Infisical, never stored in code. Every PR runs gitleaks. The adversarial Codex↔Opus review loop scores implementation plans on 7 weighted dimensions with mandatory failure conditions. You get compliance-ready ticket creation with a full audit trail.

👩‍💻 Software Developer

You want to ship code, not write tickets. This skill is 4 bash scripts and 7 reference docs — no servers, no databases, no runtime dependencies beyond jq, curl, perl, and bash. The state machine is in SKILL.md, the scripts are in scripts/, everything is readable and extensible. Add a research source, change the scoring rubric, customize the ticket template, add a Linear operation. You get a well-architected tool you can read, understand, and modify in an afternoon.

Already purchased? Jump to Getting Started & Onboarding.

The Premise

You already have a digital employee. It runs on OpenClaw. It reads your messages, checks your calendar, searches the web, writes code, manages your files. It's useful.

But right now, it writes tickets like an intern.

This skill changes that. When you install the Linear Skill from SkillBar, your digital employee becomes a product manager — one that writes better tickets than most humans, never forgets context, never takes a sick day, and costs you a tiny fraction of the real thing.

What You're Replacing

A Product Manager in Vancouver, BC costs:

Line Item	Annual Cost (CAD)
Base salary	$108,000
Benefits (health, dental, vision)	$12,000
CPP + EI employer contributions	$6,500
Equipment, software, office	$8,000
Vacation + stat holidays (paid, non-productive)	$12,500
Recruiting & onboarding (amortized)	$5,000
Fully loaded total	~$152,000/yr

That's $12,700/month for someone who — let's be honest — spends 40% of their time in meetings, 30% writing tickets, 20% in Slack, and 10% doing the strategic work you actually hired them for.

The ticket-writing part? That's what this skill does. All day. Every day. Instantly.

What Your Digital Employee Learns

When you upgrade your OpenClaw agent with this skill, it gains the abilities of a best-in-class product owner:

1. Structured Ticket Creation That Actually Works

Your agent stops writing vague one-liners and starts producing complete, execution-ready tickets. Every ticket follows the same rigorous structure — no drift, no lazy shortcuts, no "I'll fill in the details later."

Required sections (every ticket, every time):

Title — clear, actionable, verb-first format (e.g., "Build outgoing message secret scanner")
Type — classified as feature, bug, task, skill, or oss-contribution
Priority — mapped to Linear's numeric system (1=Urgent 🔴, 2=High 🟠, 3=Medium 🟡, 4=Low 🟢) using context-aware heuristics:
- "ASAP" or "critical" → Urgent (1)
- Mentions a deadline or blocker → High (2)
- Default for features → Medium (3)
- Documentation/cleanup → Low (4)
- Bug severity: crash/data-loss = Urgent, wrong-output = High, cosmetic = Low
User Story — real personas, real goals, real benefits: "As a [persona], I want [goal] so that [benefit]"
Description — full context, background, and motivation (what and why)
Acceptance Criteria — numbered, testable Given/When/Then conditions:
1. Given X, when Y, then Z
2. Performance: completes in < Ns
3. Error case: handles failure gracefully
Definition of Done — explicit checklist:
- Code complete and reviewed
- Tests written and passing
- Documentation updated
- Deployed to staging
- Product sign-off
Testing Plan — broken into unit (key functions), integration (API contracts), and e2e (critical path)
Cost Estimate — T-shirt sizing with hours and reasoning:
- S: 2–6h — isolated change, single file
- M: 1–2d — multi-file, needs testing
- L: 3–5d — cross-service, needs design
- XL: 1–2w+ — architecture change, migration
Mini-PRD — problem, solution, scope, and explicit non-goals
Research Summary — findings from the 6-platform search (prior art, community discussion, related issues)
Dependencies & Blockers — what must exist first, what other tickets/services are affected
Risk Assessment — what could go wrong, security implications, data concerns, mitigation plan
Success Metrics — how to measure post-deploy impact (not just "tests pass")

Additional sections by complexity tier:

Section	Simple	Standard	Complex
Architecture Notes	❌	Optional	✅ Required
Implementation Plan	❌	✅ Required	✅ Required
Review Trail (scoring history)	❌	✅ Required	✅ Required
Rollback Plan	Optional	Optional	✅ Required
Migration Plan	❌	If needed	✅ Required
Environment Requirements	❌	If needed	✅ Required
Observability (logging, monitoring, alerts)	❌	Optional	✅ Required
Documentation Updates	Optional	Optional	✅ Required
Competitive Analysis	❌	Optional	Optional
Stakeholder Sign-off	❌	❌	✅ Required

Complex tickets arrive with rollback plans, migration steps, observability requirements, and stakeholder sign-off checklists. Your agent doesn't skip sections because it's Friday afternoon.

2. Awareness of Leading-Edge Patterns and Anti-Patterns

Before writing a single line of a ticket, your agent researches across 6 platforms — from the broadest community knowledge down to your own codebase:

Community & Ecosystem (patterns, anti-patterns, prior art):

X/Twitter — catches real-time developer sentiment, announcements, and warnings. If someone just tweeted "don't use library X, it has a critical vulnerability," your agent knows before your ticket recommends it.
Discord — finds relevant technical discussions in community servers. Developer communities often share implementation details in Discord that never make it to blog posts.
Reddit — surfaces battle-tested advice, pain points, and workarounds from r/programming, r/webdev, and niche subreddits. The "I tried this and here's what broke" posts that save your team days of debugging.
GitHub — finds related issues and PRs in the open-source ecosystem. If someone already built what you're describing and open-sourced it, your ticket will reference it. If there's a known bug in a dependency you're about to use, it'll surface.

Your Backlog & Codebase (internal context):

Linear — searches your existing backlog for duplicates and related work. Filters by team when specified, so you're not wading through irrelevant results from other teams. Also cross-references completed sibling tickets in the same team/project for lessons learned, ADR references, and architectural patterns that should carry forward.
Greptile — semantic search across your indexed codebase. Finds the specific files, functions, and line numbers relevant to the work. Surfaces existing patterns your team already established, architectural decisions already documented, and code that should be extended rather than rewritten. (Requires Greptile account with indexed repos — see Requirements.)

Each source is independently controllable. Skip any source with flags (--skip-x, --skip-discord, --skip-github, --skip-greptile). Missing tools or credentials produce warnings, not failures — the skill gracefully degrades. If you don't have a Greptile account, everything else still works. If gh CLI isn't installed, GitHub search is skipped with a note.

ADR awareness: The skill checks your decisions repository (e.g., skillbar-ai/decisions) for applicable Architecture Decision Records and links them in the ticket description. Your devs don't accidentally violate decisions the team already made.

For standard and complex work, the research feeds into a Codex↔Opus adversarial review loop — see section 4 below.

3. Accurate, Reliable Ticket Creation in Linear

Your agent talks directly to Linear's GraphQL API. No copy-paste. No manual data entry. No formatting issues.

Issue creation:

Multiline markdown preserved perfectly — code blocks, headers, bullet lists, nested content. Uses jq --rawfile to inject the ticket body exactly as written, with no escaping artifacts.
Priority mapping based on contextual heuristics (urgency keywords, deadlines, blocker mentions, bug severity)
Team and project routing — resolves team IDs, project IDs, workflow states, and labels dynamically from your workspace
Label assignment — attaches relevant labels from your team's label set
State resolution — automatically targets the first "unstarted" workflow state (typically "Todo" or "Backlog")

Issue updates:

Modify existing tickets — change title, description, priority, state, labels, assignee
Useful for iterating on drafts or updating tickets after creation

Workspace introspection:

List teams — enumerate all teams in your workspace with IDs and keys
List projects — get all projects for a specific team
List workflow states — see available states (Todo, In Progress, Done, etc.) with types and positions
List labels — get all labels for a team with names and colors
Custom GraphQL — pass arbitrary queries via --query-file for anything the built-in operations don't cover

Duplicate prevention:

Every ticket creation starts with a search across your Linear backlog
Optional team filtering (--team) narrows results to the relevant team
Agent presents duplicate candidates before proceeding — you decide whether to continue, merge, or cancel

Human approval gate:

Nothing gets created without your explicit approval
Draft posted to Discord with ✅ Create / ✏️ Edit / ❌ Cancel options
Full ticket body posted as a thread reply (auto-split across messages if > 2000 chars)
Edit triggers regeneration with version increment — your agent tracks draft versions
Cancel marks the draft as abandoned with no API call

Reliability:

Retries — 3 attempts with exponential backoff on server errors (5xx)
Rate limiting — respects Linear's 400 req/hr budget with 1-second delays between calls; honors 429 responses with the server's retryAfter value
GraphQL error handling — extracts and surfaces GraphQL-level errors (not just HTTP errors)
Input validation — validates JSON payloads before sending, checks --body-file exists, enforces operation-specific constraints

4. AI-Powered Plan-Review Loop (Standard & Complex Tickets)

For non-trivial work, your agent doesn't just write a ticket — it generates and stress-tests an implementation plan through an adversarial AI loop.

How the loop works:

Codex CLI (GPT-5.3) generates a detailed implementation plan:
- Architecture approach and design decisions
- File changes with exact paths and function signatures
- API contracts (if applicable)
- Data/schema migration steps (if applicable)
- Test strategy (unit, integration, e2e)
- Security considerations
- Rollback approach

Opus (Claude) reviews the plan against a 7-dimension weighted scoring rubric:

Dimension	Weight	What It Checks
Implementability	20%	Zero ambiguity — any engineer can build from the spec
Technical Correctness	20%	APIs valid, patterns sound, no broken queries
Completeness	15%	All required areas addressed with concrete detail
Security/Privacy	15%	Secrets handled, auth correct, no data exposure
Edge Cases	10%	Failure modes, error handling, boundary conditions
Testability	10%	Acceptance criteria are measurable and verifiable
Operational Readiness	10%	Rollback, monitoring, migration, deployment plan

Opus returns structured feedback:

{
  "score": 7,
  "critical_findings": ["..."],
  "must_fix": ["..."],
  "nice_to_have": ["..."],
  "strengths": ["..."]
}

If score < 9, must-fix items are fed back to Codex as "Prior Feedback" and the loop continues.
Loop terminates when:
- Score ≥ 9/10 and zero critical findings and all must-fix items addressed
- Or max 5 iterations reached (in practice, most converge in 2–3)

Mandatory failure conditions (cap score at 6, force another iteration):

Any security vulnerability (secret exposure, auth bypass)
Broken API call that will fail at runtime
Missing core logic for the primary use case
No error handling for likely failure modes
Ambiguous enough that two engineers would build different things

Complexity determines behavior:

Tier	Plan Loop	Expected Iterations	Time Added
Simple	Skipped entirely	0 — one-pass draft	0
Standard	Yes	1–2	30–90 seconds
Complex	Yes, strict gate	3–5	2–4 minutes

The review trail (iteration scores and findings) is included in the ticket itself — your devs can see exactly how the plan evolved and what was challenged.

How It Works (The 60-Second Version)

You: "Create a ticket for adding rate limiting to the API"

Your Agent:
  1. Classifies → feature, standard complexity
  2. Searches Linear for duplicates → finds 0, cross-references completed sibling tickets
  3. Searches your codebase via Greptile → finds existing auth middleware to extend
  4. Searches X, Discord, Reddit, GitHub for patterns & anti-patterns → finds 3 approaches
  5. Checks decisions repo for relevant ADRs → links API design ADR
  6. Generates implementation plan via Codex → Opus scores 7/10 (missing rate limit storage strategy)
  7. Codex revises with Opus feedback → Opus scores 9/10 ✅
  8. Assembles structured ticket with all required + standard sections
  9. Saves draft as JSON (version 1) with full metadata
  10. Posts summary to Discord with ✅/✏️/❌ buttons + full body in thread

You: ✅

Your Agent:
  → Resolves team ID, project ID, workflow state, labels
  → Creates issue via Linear GraphQL API
  → "Created THE-142: Add rate limiting middleware to API gateway"
  → https://linear.app/your-workspace/issue/THE-142/...

Total time: under 3 minutes for a ticket that would take a human PM 20–40 minutes.

The Math

	Human PM	Digital Employee + Linear Skill
Annual cost	~$152,000 CAD	OpenClaw subscription + skill purchase
Tickets per day	3–5 (between meetings)	Limited only by Linear's 400 req/hr API budget
Consistency	Varies by energy, mood, day	Identical structure and quality every time
Research depth	Whatever they Google in 10 min	6 platforms, every time, automatically
Available hours	8hrs/day, minus meetings/Slack	24/7/365
Ramp-up time	3–6 months to learn your codebase	Immediate (Greptile indexes your repos)
Sick days / vacation	25+ days/year	Zero
Quality gate	Self-review (if they remember)	Adversarial AI scoring to 9/10 on 7 dimensions
Institutional memory	Leaves when they quit	Permanent — searches your full backlog + codebase every time
Section compliance	Template drift over time	100% template adherence, tier-appropriate sections

This isn't about replacing your PM entirely — it's about giving your digital employee the ticket-writing superpower so your human PM can focus on strategy, stakeholder alignment, and the work that actually requires a human in the room.

Or, if you're a startup without a PM at all, this is your PM for ticket quality.

Why Subscribe — The Evergreen Product Manager

A one-time skill purchase is a snapshot in time. The patterns it knows, the research sources it uses, the scoring rubric, the ticket template — they're frozen the day you install it. But product management best practices evolve. New tools emerge. Anti-patterns get discovered. New vulnerabilities surface.

A product manager you hire stays current because they read blogs, attend conferences, and learn from every sprint. Your digital product manager should too.

That's why this skill is a monthly subscription, not a one-time purchase. When you subscribe, your digital employee's PM capabilities stay current — because we do the work to keep them there.

What You Get Every Month

🔍 Expanding Research Sources Today: X, Discord, Reddit, GitHub, Linear, Greptile. We're continuously evaluating and adding new sources — Stack Overflow, Hacker News, product-specific communities, industry-niche forums. When we add a source, your agent gets it automatically. Your tickets get richer context without you changing anything.

📋 Evolving Ticket Templates We use this skill ourselves, every day. When we discover that a section isn't pulling its weight, we refine it. When we find that certain acceptance criteria formats lead to fewer clarification rounds, we update the template. When new compliance requirements emerge, we add sections. Your agent's output improves month over month.

🧠 Smarter Prompts & Scoring The Codex plan prompt and Opus review prompt are living documents. As AI models improve and we learn what produces better implementation plans, we tune the prompts. The scoring rubric gets recalibrated based on real-world outcomes — which dimensions actually predict ticket quality, and at what weights. Your agent's judgment gets sharper.

🔌 New Tracker Integrations Linear today. When demand warrants: Jira, GitHub Issues, Shortcut, Asana, and others. Subscribers don't buy a new skill — the adapter ships as an update. Your agent gains new capabilities without a migration.

🔒 Security Updates New token patterns to redact. New sanitization rules for emerging credential formats. Updated CI checks. The threat landscape changes monthly; your skill keeps pace. When a new API key format appears in the wild, we add it to the redaction pipeline before it can leak through your tickets.

📚 Pattern & Anti-Pattern Intelligence We attend conferences, monitor developer communities, and track the evolving landscape of software engineering practices. When the industry shifts — new architectural patterns, deprecated approaches, emerging best practices — your agent's research and recommendations reflect it. Your tickets don't recommend patterns that were best practice last year but anti-patterns today.

The Subscription Difference

	One-Time Purchase	Monthly Subscription
Research sources	Frozen at purchase	New sources added continuously
Ticket template	Static	Refined monthly from real usage
Scoring rubric	Fixed weights	Recalibrated from outcomes
Tracker support	Linear only	New integrations as they ship
Security patterns	Point-in-time	Updated as new threats emerge
AI prompts	Snapshot	Tuned as models improve
Best practices	February 2026	Always current

How Updates Are Delivered

Your agent notifies you when an update is available. You decide when to install it.

Your Agent: "🔄 Linear Skill v2.4 available — 2 new research sources,
            updated scoring rubric, 3 new token redaction patterns.
            Say 'update' to install, or 'changelog' for details."

You: "update"

Your Agent: "✅ Linear Skill updated to v2.4. 9/9 tests passing."

Updates never auto-deploy without your approval. Your agent surfaces what changed and lets you decide when to pull. You stay in control — critical for teams that need stability during sprints or enterprises with change management policies.

Behind the scenes: SkillBar checks for new versions via your agent's heartbeat cycle. When a new version is available, your agent gets a notification with the changelog. One word from you and it pulls, installs, and verifies tests pass — all without leaving the conversation.

Think of it this way: hiring a PM who never reads another blog post, never attends another conference, and never learns from another sprint would be absurd. A frozen skill is the same thing. The subscription ensures your digital PM keeps learning — because we keep learning and push every improvement to your agent.

What's in the Box

When you purchase this skill from SkillBar, you get:

5 Production Scripts

Script	Purpose	Key Capabilities
`linear-api.sh`	Linear GraphQL transport	7 operations (teams, projects, states, labels, search, create, update), `--body-file` for multiline markdown, `--vars-file` for large payloads, `--query-file` for custom GraphQL, 3x retry with backoff, 429 rate limit handling, jq ≥ 1.6 validation
`search-context.sh`	Multi-platform research	6 sources (X, Discord, Reddit, GitHub, Linear, Greptile), per-source skip flags, `--repository` passthrough for per-call Greptile repo override, team filtering, specific partial-config warnings (e.g., "API key set but no GitHub token"), graceful degradation, unified JSON output
`greptile-api.sh`	Semantic codebase search	Greptile `/v2/search` API, configurable repository/branch/remote, session ID support for conversational context across searches, 30s timeout, normalized output shape
`index-repo.sh`	Greptile repo indexing	`POST /v2/repositories` with `--reload` (reprocess), `--notify` (callback), `--branch`, `--remote` flags. Required one-time setup before Greptile search works — indexes your codebase so `/v2/search` has something to query
`sanitize-snippet.sh`	Security sanitizer	Perl multiline pass (script tags → HTML tags → fenced code blocks), sed token redaction (15+ patterns: API keys, bearer tokens, AWS creds, npm tokens, etc.), control character cleanup, configurable `--max-chars` truncation (default 2000)

7 Reference Documents

Document	What It Contains
`ticket-sections.md`	Complete ticket template with all required and conditional sections, tier matrix (simple/standard/complex), section formats with examples
`priority-mapping.md`	Linear priority values (1–4) with emoji, heuristic rules for automated classification based on keywords, deadlines, bug severity
`output-contract.md`	Draft JSON schema (`draft_id`, `status`, `version`, `ticket_markdown`, `summary_markdown`, full `metadata` object), Discord output strategy (summary + thread reply + buttons), button behavior spec
`codex-plan-prompt.md`	Prompt template for Codex plan generation — required deliverables (architecture, file changes, API contracts, migration, tests, security, rollback), constraints, output format
`opus-review-prompt.md`	Prompt template for Opus scoring — 7 dimensions, scoring rules, mandatory failure conditions, required output format (JSON + detailed notes)
`scoring-rubric.md`	Weighted scoring dimensions (7), score thresholds (9–10 = ship, 7–8 = one revision, 5–6 = major revision, 3–4 = rethink, 1–2 = start over), mandatory failure conditions, convergence criteria, revision instruction format
`linear-api-ref.md`	API endpoint, auth method, rate limits (400 req/hr), workspace info, all 7 operation examples with exact CLI usage, state resolution strategy, jq cheat sheet for common extractions

Full Documentation & Quality Assurance

Asset	Details
`PRD.md`	Product Requirements Document — problem statement, solution overview, target users, user stories (core, research, quality, workflow), success metrics, scope/non-goals
`ADR.md`	Architecture Decision Record — 4 documented decisions: (1) Linear over Jira/GitHub Issues, (2) Codex↔Opus loop over single-pass/self-review, (3) Multi-platform research over Linear-only, (4) Org-wide CI reusable workflow
`README.md`	Installation, usage, directory structure, flow diagram, feature list
`test_phase1.sh`	9 automated tests with full mocks: (1) token redaction + script stripping, (2) multiline code block replacement, (3) multiline body preservation via `--body-file` with mock curl, (4) Greptile integration + sanitization, (5) Linear `searchIssues` field correctness, (6) Greptile env validation, (7) index-repo payload shape, (8) repository override passthrough, (9) partial-config warning messages
`ci.yml`	CI pipeline via org-wide reusable workflow: ShellCheck, shfmt formatting, bash syntax validation, gitleaks secret scanning, jq version gate, extensionless shebang detection, test runner
`greptile.json`	Greptile repository configuration
`CODEOWNERS`	GitHub code ownership for review routing

Everything is bash and jq — no runtime dependencies, no servers, no databases. It runs wherever your OpenClaw agent runs.

The State Machine (How Your Agent Thinks)

Your agent doesn't freestyle. It follows a deterministic state machine with explicit transitions:

INTAKE → CLASSIFY → RESEARCH → PLAN → ASSEMBLE → DRAFT → APPROVAL → CREATE → DONE
                                 ↓                                ↓         ↓
                              (skip if                        ASSEMBLE   CANCELED
                               simple)                       (on edit)

State	What Happens	Output
INTAKE	Collects the raw idea, intent, and constraints from the user	Structured brief
CLASSIFY	Determines ticket type (`feature\|bug\|task\|skill\|oss-contribution`) and complexity (`simple\|standard\|complex`)	Type + tier
RESEARCH	Runs `search-context.sh` — Linear duplicates, Greptile codebase search, GitHub/Reddit/X/Discord community search, ADR lookup, sibling ticket cross-reference	`context.json` with unified results
PLAN	(Standard/complex only) Codex generates plan → Opus scores → iterate until ≥ 9/10 or max 5 rounds	Reviewed implementation plan + scoring trail
ASSEMBLE	Builds ticket markdown from `ticket-sections.md` template, maps priority, includes research summary and plan	Complete ticket markdown
DRAFT	Saves draft JSON to `tmp/linear/drafts/<draft_id>.json`, posts summary + body to Discord	Persisted draft (versioned)
APPROVAL	Waits for human action: ✅ Create, ✏️ Edit, ❌ Cancel	User decision
CREATE	Resolves team/project/state/label IDs → calls `issueCreate` via GraphQL → returns identifier + URL	`THE-142` + Linear URL
DONE	Returns final summary with identifier, URL, and ticket metadata	Confirmation
CANCELED	Marks draft as canceled, no API call made	Clean exit

Edit loop: When you hit ✏️, the agent asks what to change, regenerates the draft (incrementing the version number), and returns to APPROVAL. You can iterate as many times as needed before creating.

Allowed transitions are enforced — the agent cannot skip from INTAKE to CREATE, cannot create without approval, cannot bypass research. The state machine is the guardrail.

Security

Every external snippet that enters the system passes through sanitize-snippet.sh before being persisted or displayed:

Sanitization pipeline (in order):

Perl multiline pass:
- Remove <script> tags and their contents
- Strip all HTML tags
- Replace fenced code blocks (bash, sh, python, javascript, ruby, perl, powershell) with [code block removed]
Token redaction (15+ patterns):
- lin_api_* (Linear API keys)
- sk-* (OpenAI keys)
- xoxb-*, xoxp-*, xapp-* (Slack tokens)
- whsec_* (webhook secrets)
- AKIA* (AWS access keys)
- Bearer * (bearer tokens)
- ghp_*, gho_* (GitHub tokens)
- glpat-* (GitLab tokens)
- npm_* (npm tokens)
- pypi-* (PyPI tokens)
- dop_v1_* (DigitalOcean tokens)
- SG.* (SendGrid keys)
- All replaced with [REDACTED]
Control character cleanup — collapses to spaces
Truncation — configurable --max-chars (default 2000)

Secret management: All credentials (LINEAR_API_KEY, Greptile tokens) are injected at runtime via Infisical — never stored in code, config, or environment files.

CI scanning: Every PR runs gitleaks to catch accidentally committed secrets before they reach main.

Requirements

Required:

OpenClaw agent (your digital employee)
Linear workspace with a Personal API key
jq >= 1.6 — JSON processing (required for --rawfile support)
curl — HTTP calls
perl — multiline sanitization
bash — script runtime

Optional (graceful degradation when missing):

Greptile account — enables semantic codebase search. Requires GREPTILE_API_KEY, GREPTILE_GITHUB_TOKEN (GitHub PAT with repo read), and GREPTILE_REPOSITORY (e.g., owner/repo). Without it, codebase search is skipped with a warning.
Codex CLI — enables the plan-review loop for standard/complex tickets. Without it, your agent generates plans directly (still good, just not adversarially reviewed).
GitHub CLI (gh) — enables GitHub issue/PR search. Without it, GitHub ecosystem search is skipped.
Discord channel access — for the draft approval flow with buttons. Without it, approval happens in whatever channel you're chatting in.

All optional dependencies follow the same pattern: present = used, missing = skipped with warning, nothing breaks.

Getting Started & Onboarding

Step 1: Install the Skill

cp -R skill-linear/ ~/.openclaw/skills/linear/
chmod +x ~/.openclaw/skills/linear/scripts/*.sh

Your OpenClaw agent auto-discovers skills from the SKILL.md description — no configuration needed.

Step 2: Set Your Linear API Key

Get a Personal API key from Linear → Settings → API → Personal API keys.

Option A — Environment variable (simplest):

export LINEAR_API_KEY=lin_api_xxxxx

Option B — Infisical (recommended for teams):

infisical secrets set LINEAR_API_KEY=lin_api_xxxxx --env=prod --path=/credentials

Then ensure your agent runs scripts with infisical run --env=prod --path=/credentials -- <command>.

Step 3: Verify It Works

Ask your agent:

"Create a test ticket: add a hello world endpoint"

You should see it classify, search for duplicates, build a structured draft, and present it for approval. Hit ❌ Cancel if you don't want to actually create the test ticket.

Step 4: Optional — Enable Greptile (Codebase Search)

For your agent to search your actual codebase when writing tickets:

Create a Greptile account

Set three environment variables:

export GREPTILE_API_KEY=...
export GREPTILE_GITHUB_TOKEN=...   # GitHub PAT with repo read access
export GREPTILE_REPOSITORY=owner/repo

Index your repo (required one-time setup — Greptile needs to process your codebase before search works):
```
./scripts/index-repo.sh --repository owner/repo --reload
```
That's it — the skill auto-detects Greptile and includes codebase results. To re-index after significant changes, run index-repo.sh --reload again.

Step 5: Optional — Enable the Plan-Review Loop

For adversarial quality scoring on standard/complex tickets:

Install Codex CLI and authenticate
Ensure your OpenClaw agent has access to Opus (Claude) — this is your default if you're on OpenClaw

Both are auto-detected. Without them, your agent writes plans directly (still structured, just not adversarially reviewed).

Step 6: Optional — Enable GitHub Ecosystem Search

brew install gh
gh auth login

The skill auto-detects gh and includes GitHub issues/PRs in research results.

Tips for Getting the Most Out of It

Be specific about priority — say "urgent" or "this blocks X" and it maps correctly
Mention the team or project — "create this in the Platform project" routes it precisely
For complex work, let the loop run — first Codex draft is usually 6–7/10, but by iteration 3 it's consistently 9+
Review the research summary — it sometimes surfaces duplicates or related work you forgot about
Edit freely — hit ✏️ and tell your agent what to change; it regenerates without starting from scratch
Use skip flags for speed — if you know you don't need Reddit/X context, ask your agent to skip those sources

Troubleshooting

Problem	Fix
`LINEAR_API_KEY is required`	Set the env var or configure Infisical
`jq >= 1.6 required`	`brew install jq` (Mac) or update your system jq
Greptile results empty	Verify your repo is indexed in Greptile's dashboard and all 3 env vars are set
Ticket body looks garbled	Ensure you're on `jq >= 1.6` — older versions lack `--rawfile` support
Duplicate search returns nothing	Check that your Linear API key has read access to the target team
Draft buttons don't respond	Known issue — type "approve", "edit", or "cancel" as text instead
Rate limited by Linear	The skill auto-handles 429s with backoff, but if you're creating many tickets in a burst, space them out
Research step is slow	Skip sources you don't need: ask your agent to `--skip-x --skip-discord`

Pricing

A fully loaded Product Manager in Vancouver costs $12,700/month. Your digital product manager costs a fraction of that — and writes better tickets.

	Starter	Pro	Enterprise
Price	$497/mo	$997/mo	$2,497/mo
Best for	Solo devs, small teams getting started	Startups & SMBs who want the full capability	Organizations with 100+ employees
Core skill (state machine, ticket creation, Linear API)	✅	✅	✅
Monthly updates (templates, prompts, security patterns)	✅	✅	✅
Linear integration	✅	✅	✅
Community research (X, Discord, Reddit, GitHub)	✅	✅	✅
Duplicate detection	✅	✅	✅
Human approval gate	✅	✅	✅
Greptile codebase search	❌	✅	✅
Codex↔Opus plan-review loop	❌	✅	✅
ADR awareness & sibling ticket cross-reference	❌	✅	✅
Custom GraphQL queries	❌	✅	✅
Additional tracker integrations (Jira, GitHub Issues, etc.)	❌	❌	✅ As they ship
Custom tracker adapters for your workflow	❌	❌	✅
Custom ticket template & scoring rubric tuning	❌	❌	✅
Dedicated support channel	❌	❌	✅
SLA	❌	❌	✅
vs. a human PM ($12,700/mo)	96% less	92% less	80% less

Starter — $497/mo

Your digital employee gets the core product manager capability: structured ticket creation with 15+ required sections, 6-platform community research, duplicate detection, priority mapping, and human approval — all backed by monthly updates. Everything you need to stop writing bad tickets, at less than the cost of a single day of a human PM's salary.

Pro — $997/mo

Everything in Starter, plus the features that make the difference between good tickets and exceptional ones. Greptile searches your actual codebase so tickets reference your existing code. The Codex↔Opus adversarial review loop stress-tests implementation plans to 9/10 quality. ADR awareness ensures tickets respect architectural decisions your team already made. Custom GraphQL gives you escape hatches for anything the built-in operations don't cover. This is the plan most teams choose.

Enterprise — $2,497/mo

For organizations with 100+ employees.

Everything in Pro, plus the enterprise layer. Custom tracker adapters when you need Jira, GitHub Issues, or Shortcut alongside Linear. Custom ticket template and scoring rubric tuning to match your organization's specific standards. A dedicated support channel and SLA. As new tracker integrations ship, Enterprise subscribers get them first. Still 80% less than a single human PM — and it scales across every team in your org without hiring another one.

FAQ

General

Q: Does this replace my product manager? A: No. It replaces the ticket-writing part of what a PM does — which is typically 30% of their time. Your human PM focuses on strategy, stakeholder alignment, customer discovery, and the judgment calls that require a human. Your digital employee handles the structured output.

Q: What if I don't have a PM at all? A: Then this is your PM for ticket quality. You provide the ideas and decisions; the skill handles research, structure, and creation. Many startups and solo developers use it exactly this way.

Q: Does it work with Jira / GitHub Issues / Asana? A: Not today — it's Linear-only. The architecture (GraphQL wrapper + state machine) is designed to support adapters for other trackers if demand exists. Linear was chosen for its clean API, fast product, and strong adoption in the target user base (small-to-mid teams, startups).

Q: What does "adversarial review loop" mean? A: Two different AI models with different strengths challenge each other. Codex (GPT-5.3) generates implementation plans — it's strong at code architecture. Opus (Claude) reviews and scores them — it's strong at critical analysis and finding gaps. They iterate until quality hits 9/10. A single model reviewing its own work misses ~70% of the issues this loop catches.

Q: How is this different from asking ChatGPT to write a ticket? A: Five ways: (1) It searches 6 platforms for context before writing anything. (2) It enforces a consistent structure with 15+ required sections. (3) It runs an adversarial quality gate, not just a single generation pass. (4) It creates the ticket directly in Linear via API — no copy-paste. (5) It prevents duplicates by searching your existing backlog first.

Technical

Q: What languages/frameworks does it require? A: Bash and jq. That's it. No Python, no Node, no Docker, no database. It runs wherever your OpenClaw agent runs — Mac, Linux, WSL.

Q: How does it handle secrets? A: Three layers: (1) Credentials are injected at runtime via Infisical, never stored in files. (2) Every external snippet passes through a sanitizer that redacts 15+ token patterns before persistence. (3) CI runs gitleaks on every PR to catch accidentally committed secrets.

Q: Can I customize the ticket template? A: Yes. Edit references/ticket-sections.md to add/remove/modify sections. Edit the tier matrix to change which sections are required per complexity level. Edit references/priority-mapping.md to change classification heuristics.

Q: Can I add my own research sources? A: Yes. Add a numbered section to scripts/search-context.sh following the existing pattern: check tool availability → call API → merge results into the JSON output → add warning on failure. The skill handles the rest.

Q: What if Greptile / GitHub CLI / Codex isn't available? A: Everything degrades gracefully. Each optional dependency follows the same pattern: present = used, missing = skipped with a warning in the output. The core flow (classify → search Linear → assemble → draft → approve → create) always works with just a Linear API key.

Q: How does it handle Linear rate limits? A: Built-in 1-second delay between API calls. On 429 responses, it reads the server's retryAfter value and waits. On 5xx errors, it retries up to 3 times with exponential backoff. The 400 req/hr budget is more than enough for normal usage — you'd need to create 400+ tickets in an hour to hit it.

Q: Can I use custom GraphQL queries? A: Yes. Pass --query-file my-query.graphql to linear-api.sh with any valid Linear GraphQL query. The 7 built-in operations cover the common cases, but the escape hatch is there for anything custom.

Pricing & Value

Q: Why is it a subscription and not a one-time purchase? A: Because a frozen skill is a PM who stopped learning. We use this skill ourselves, attend conferences, monitor developer communities, and continuously improve the research sources, ticket templates, scoring rubrics, AI prompts, and security patterns. Subscribers get every improvement automatically. A one-time purchase would freeze your digital PM's knowledge on the day you bought it — and that's not how good product management works.

Q: What does it cost to run? A: The monthly subscription covers the skill and all updates. Running it costs whatever your OpenClaw subscription and LLM API usage costs — typically pennies per ticket. The optional Codex↔Opus review loop adds ~30 seconds of compute for standard tickets. Compare the total to $12,700/month for a human PM.

Q: What's the ROI? A: If a human PM spends 30 minutes per well-written ticket and writes 4 tickets/day, that's 2 hours/day or ~$380/day at fully loaded Vancouver rates. This skill writes comparable-or-better tickets in under 3 minutes each. The subscription pays for itself on day one.

Q: Do updates install automatically? A: No. Your agent notifies you when an update is available and shows you what changed. You say "update" when you're ready. Nothing changes on your machine without your explicit approval. This is important for teams mid-sprint and enterprises with change management policies.

Q: What happens if I cancel? A: You keep the version you have — it doesn't stop working. You just stop receiving updates: new research sources, template refinements, tracker integrations, security patches, and prompt improvements. Your digital PM freezes in time.

Q: Is there a free trial? A: Check SkillBar for current pricing and trial availability.

Built by SkillBar for OpenClaw digital employees.

whistlermike/product-manager-skill.md