╔════════════════════════════════════════════════════════════════════╗
║                                                                    ║
║   ██████╗ ███╗   ███╗    ███████╗██╗  ██╗██╗██╗     ██╗     ███████╗
║   ██╔══██╗████╗ ████║    ██╔════╝██║ ██╔╝██║██║     ██║     ██╔════╝
║   ██████╔╝██╔████╔██║    ███████╗█████╔╝ ██║██║     ██║     ███████╗
║   ██╔═══╝ ██║╚██╔╝██║    ╚════██║██╔═██╗ ██║██║     ██║     ╚════██║
║   ██║     ██║ ╚═╝ ██║    ███████║██║  ██╗██║███████╗███████╗███████║
║   ╚═╝     ╚═╝     ╚═╝    ╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚══════╝
║                                                                    ║
║   46 battle-tested skills + 6 command workflows                    ║
║   Claude Code • Cursor • Codex  • n8n • OpenClaw • and more ...    ║
║                                                                    ║
║   v0.7 • Mar 9, 2026 • CC BY-NC-SA 4.0                             ║
╚════════════════════════════════════════════════════════════════════╝

Train AI agents to do product management work like a pro.

Frame problems, hunt opportunities, scaffold validation experiments, and kill bad bets fast. With battle-tested frameworks from Teresa Torres, Geoffrey Moore, Amazon, MITRE, and much more from product management's greatest hits.

This release is about making the library easier to trust and easier to use.

As this repo grows, the standard has to rise with it. So v0.7 focuses on the parts users actually feel:

• finding the right skill faster,
• understanding when to use it,
• getting cleaner activation behavior,
• and trusting that the repo is being actively tightened, not just expanded.

1. You spend less time guessing which skill to use.
2. Skills are more likely to show up in the situations where you actually need them.
3. The library becomes easier to navigate as it grows, not more chaotic.
4. Quality becomes a maintained promise, not a one-time cleanup.

• Trigger-oriented description updates across the skill library so skills answer both "what it does" and "use this when..."
• New intent frontmatter field so every skill can keep a sharp trigger description and a richer deeper-purpose summary
• New trigger-readiness auditing in scripts/check-skill-triggers.py
• Trigger checks wired into scripts/test-library.sh
• New find-a-skill.sh --mode trigger for discovering skills by use-case language, best_for, and scenarios
• New Streamlit (beta) Find My Skill mode so users can describe a situation in plain English and get recommended skills with clear next actions
• Streamlit navigation now separates Learn, Find My Skill, and Run Skills so first-time users can move from confusion to action faster
• Contributor docs updated so future skills follow the same tighter standard
• Cross-checked the tighter standard against Anthropic's Complete Guide to Building Skills for Claude

Release note: docs/announcements/2026-03-09-v0-7-skill-quality-trigger-clarity.md

You asked, we listened. We took a moment to create comprehensive instructions on how to install, integrate, or otherwise use any one or all of these skills.

What shipped:

• docs/Using PM Skills 101.md as the complete beginner-first guide
• docs/Platform Guides for PMs.md as the pick-your-tool index
• docs/Using PM Skills with Slash Commands 101.md for Claude /slash workflows like /pm-story and /pm-prd
• New PM-friendly platform docs for Claude Code, Claude Desktop, Claude Cowork, ChatGPT Desktop, OpenClaw, n8n, LangFlow, and Python agents
• Updated START_HERE.md with comfort-level paths (chat-first, terminal-first, automation-first)

How to make the best use of this release:

1. Start with docs/Using PM Skills 101.md
2. Choose your platform in docs/Platform Guides for PMs.md
3. Run one real task with one skill before scaling to multi-skill workflows

Release note: docs/announcements/2026-03-08-v0-65-onboarding-integration-guides.md

We added a command layer and fast navigation system while keeping skills as the source of truth.

What shipped:

• START_HERE.md for 60-second onboarding
• commands/ directory with reusable multi-skill workflows
• catalog/ generated indexes for quick browsing
• New helper scripts: run-pm.sh, find-a-command.sh, test-library.sh, and generate-catalog.py
• Command validation with scripts/check-command-metadata.py

Release note draft: docs/announcements/2026-03-06-v0-6-navigation-commands.md

We launched a new Streamlit (beta) interface for local skill test-driving.

What shipped:

• Local playground at app/main.py with guided browsing and session flows
• Multi-provider support (Anthropic, OpenAI, Ollama) with provider/model picker
• Environment-variable-only API handling (app/.env.example) for safer defaults
• Workflow UX upgrades (phase detection fix, per-phase output persistence, run-all phases control)
• Fast-model quality warnings on long workflows (especially PRD-style runs)

Docs:

• app/STREAMLIT_INTERFACE.md
• app/.env.example

Feedback welcome:

• GitHub Issues
• Dean on LinkedIn

Four new skills covering the full product leadership career arc — from PM to Director to VP/CPO — distilled from two episodes of The Product Porch podcast.

Based on Episode 42 — From PM to Director: How to Make the Shift (Part 1):

• altitude-horizon-framework (Component) — The core mental model: altitude (scope) and horizon (time), the waiter-to-operator shift, four transition zones, named failure modes, and the Cascading Context Map
• director-readiness-advisor (Interactive) — Coaches PMs and new Directors across four situations: preparing, interviewing, newly landed, and recalibrating

Based on Episode 43 — Becoming a VP & CPO: Leading Product at the Executive Level (Part 2):

• executive-onboarding-playbook (Workflow) — A 30-60-90 day diagnostic playbook for VP/CPO transitions: diagnose before acting, surface unwritten strategy, assess people, act with evidence
• vp-cpo-readiness-advisor (Interactive) — Coaches Directors and executives through the VP/CPO transition, including the CEO interview framework for evaluating roles before accepting

We found and fixed a facilitation regression in interactive flows.

What happened:

• We expected guided, step-by-step facilitation with progressive context handling.
• In practice, a brevity-focused rewrite path stripped out parts of the original facilitation modality (especially the "walk through questions" behavior).

What we changed in v0.4:

• Standardized a canonical facilitation protocol in skills/workshop-facilitation/SKILL.md.
• Rolled that source-of-truth linkage across interactive skills and facilitation-heavy workflow skills.
• Added mandatory session heads-up, Context dump bypass, and Best guess mode.
• Added stronger progress labels, interruption handling, and decision-point recommendation rules.

Credit:

• Codex identified the protocol mismatch and implemented the fix across the repo.

Announcement draft: docs/announcements/2026-02-10-v0-4-facilitation-fix.md

Post title: Product Management Skills for Your Agents
Subtitle: Because "just prompt better" is not a strategy.

Still rewriting PM prompts and getting generic AI output? I built a reusable PM Skills repo to help you make sharper decisions, docs, and outcomes faster.

• Full announcement draft: docs/announcements/2026-02-08-linkedin-launch.md
• Substack article draft: docs/announcements/2026-02-08-substack-savage-launch.md
• Announcements index: docs/announcements/README.md
• Skills repo: Product Manager Skills
• Prior prompts repo: Product Manager Prompts

46 ready-to-use PM skills + reusable command workflows that teach AI agents how to do product management work professionally—without you having to explain your process every time.

Instead of saying "Write a PRD" and hoping for the best, the agent already knows:

• ✅ How to structure a PRD
• ✅ What questions to ask stakeholders
• ✅ Which prioritization framework to use (and when)
• ✅ How to run customer discovery interviews
• ✅ How to break down epics using proven patterns

Result: You work faster, with better consistency, at a higher strategic level.

Works with: Claude Code, Cowork, OpenAI Codex, ChatGPT, Gemini, and any AI agent that can read structured knowledge.

New here? Start with START_HERE.md.

# Run a skill (artifact/analysis)
./scripts/run-pm.sh skill prioritization-advisor "We have 12 requests and one sprint"

# Run a command (multi-skill workflow)
./scripts/run-pm.sh command discover "Reduce onboarding drop-off for self-serve users"

Need discovery first?

./scripts/find-a-skill.sh --keyword onboarding
./scripts/find-a-command.sh --keyword roadmap

Commands make using skills easier without replacing skills.

• Skills stay deep and pedagogic: they are still the source of truth for frameworks and quality.
• Commands remove stitching work: one command chains the right skills in the right order.
• You start faster: less "which skill should I run first?" and fewer manual handoffs.
• Outputs are more consistent: commands enforce checkpoints, then defer to skill-level rigor.
• Teams onboard quicker: new users can run /discover or /write-prd and learn the skill system while shipping.

In short: skills provide expertise; commands provide momentum.

Want a quick local test-drive before using skills in your agent workflow?

pip install -r app/requirements.txt
streamlit run app/main.py

What you can do in v0.7:

• Learn setup and integration paths without leaving the app
• Find My Skill by describing your situation in plain English
• Run Skills with your own scenario once you know what you want

This beta interface is a feature in flight. Feedback is welcome via GitHub Issues or LinkedIn.

Before using any skill:

• Review the skill file and any linked resources. If it includes scripts/, read them before running.
• Prefer least privilege. Skills should not require secrets or network access unless explicitly documented.
• Do a quick dry run with a realistic prompt, then refine name and description for better discoverability.
• Run python3 scripts/check-skill-triggers.py --show-cases before packaging if you want a quick trigger-readiness pass.

Some skills include a scripts/ folder with deterministic helpers for calculations or formatting. These are optional, should be audited before running, and should avoid network calls or external dependencies.

Examples:

• skills/tam-sam-som-calculator/scripts/market-sizing.py
• skills/user-story/scripts/user-story-template.py

Want to create your own skills? Choose one of these utilities:

• scripts/add-a-skill.sh - Content-first, AI-assisted generation from notes/frameworks.
• scripts/build-a-skill.sh - Guided "build-a-bear" wizard that prompts section-by-section.
• scripts/find-a-skill.sh - Search skills by name/type/keyword with ranked results.
• scripts/find-a-command.sh - Search commands by name/keyword/used skills.
• scripts/run-pm.sh - Fast runner for either a skill or a command.
• scripts/test-a-skill.sh - Run strict conformance checks and optional smoke checks.
• scripts/check-skill-triggers.py - Audit frontmatter descriptions and scenario prompts for Claude-style triggering.
• scripts/test-library.sh - Validate skills, commands, and regenerate catalogs.
• scripts/zip-a-skill.sh - Build upload-ready .zip files by skill, type, or all skills.
• scripts/generate-catalog.py - Regenerate skill/command navigation indexes.

New to terminals? See scripts/README.md for a plain-language walkthrough. Power users: These scripts are designed to chain together into fast end-to-end workflows (idea -> prompt -> validation -> packaging).

What it does:

1. Analyzes your content and suggests skill types
2. Generates complete skill files with examples
3. Validates metadata for marketplace compliance
4. Updates documentation automatically

Usage:

# From a file
./scripts/add-a-skill.sh research/your-framework.md

# Guided wizard
./scripts/build-a-skill.sh

# Find a skill
./scripts/find-a-skill.sh --keyword pricing --type interactive

# Find a command
./scripts/find-a-command.sh --keyword roadmap

# Run a command workflow
./scripts/run-pm.sh command write-prd "Mobile onboarding redesign"

# Test one skill
./scripts/test-a-skill.sh --skill finance-based-pricing-advisor --smoke

# Test full library surface
./scripts/test-library.sh

# Build Claude upload zip for one skill
./scripts/zip-a-skill.sh --skill finance-based-pricing-advisor

# Build Claude upload zips for all skills
./scripts/zip-a-skill.sh --all --output dist/skill-zips

# Build Claude upload zips for one category (component|interactive|workflow)
./scripts/zip-a-skill.sh --type component --output dist/skill-zips

# Build curated starter pack
./scripts/zip-a-skill.sh --preset core-pm --output dist/skill-zips

# Show available curated presets
./scripts/zip-a-skill.sh --list-presets

# From clipboard
pbpaste | ./scripts/add-a-skill.sh

# Check available adapters
./scripts/add-a-skill.sh --list-agents

Agent support: Claude Code, Manual mode (works with any CLI), and custom adapters via scripts/adapters/ADAPTER_TEMPLATE.sh

Learn more: See docs/Add-a-Skill Utility Guide.md for complete guide. Cloning locally? Start with docs/Building PM Skills.md#local-clone-quickstart.

• Keep frontmatter name <= 64 chars and description <= 200 chars.
• Use intent for the richer repo-facing explanation of the skill, while keeping description short and trigger-oriented.
• Ensure the skill folder name matches the name value.
• Use scripts/zip-a-skill.sh --skill <skill-name> (or --type component, --preset core-pm) to generate upload-ready ZIPs.
• (Advanced) Use scripts/package-claude-skills.sh if you need unpacked upload-ready folders.
• Validate metadata with scripts/check-skill-metadata.py.
• For GitHub ZIP upload flow, see docs/Using PM Skills with Claude.md.

These 46 skills are organized into three types that build on each other:

┌───────────────────────────────────────────────────────────┐
│  WORKFLOW SKILLS (6)                                      │
│  Complete end-to-end PM processes                         │
│  Example: "Run a product strategy session"                │
│  Timeline: 2-4 weeks                                      │
└───────────────────────────────────────────────────────────┘
                         ↓ orchestrates
┌───────────────────────────────────────────────────────────┐
│  INTERACTIVE SKILLS (20)                                  │
│  Guided discovery with adaptive questions                 │
│  Example: "Which prioritization framework should I use?"  │
│  Timeline: 30-90 minutes                                  │
└───────────────────────────────────────────────────────────┘
                         ↓ uses
┌───────────────────────────────────────────────────────────┐
│  COMPONENT SKILLS (20)                                    │
│  Templates for specific PM deliverables                   │
│  Example: "Write a user story"                            │
│  Timeline: 10-30 minutes                                  │
└───────────────────────────────────────────────────────────┘

What: Reusable templates for creating specific PM deliverables (user stories, positioning statements, epics, personas, PRDs, etc.)

When to use: You need a standard template or format for a specific deliverable.

Example: "Write a user story with acceptance criteria" → Use user-story.md

What: Multi-turn conversational flows where AI asks you 3-5 adaptive questions, then offers smart recommendations based on your context.

When to use: You need help deciding which approach to take or gathering context before executing.

Example: "Which prioritization framework should I use?" → Run prioritization-advisor.md, which asks about your product stage, team size, data availability, then recommends RICE, ICE, Kano, or other frameworks.

How they work:

1. AI asks 3-5 questions about your context
2. You answer (or pick from numbered options)
3. AI offers 3-5 tailored recommendations
4. You choose one (or combine approaches)
5. AI executes using the right component skills

What: Complete PM processes that orchestrate multiple component and interactive skills over days/weeks.

When to use: You need to run a full PM workflow from start to finish (strategy session, discovery cycle, roadmap planning, PRD creation).

Example: "Align stakeholders on product strategy" → Run product-strategy-session.md, which guides you through positioning → problem framing → solution exploration → roadmap planning over 2-4 weeks.

Now that you understand the three types, here's the complete catalog:

Possible skills in development:

• Dangerous Animals of Product Management - Feature hostage negotiations and stakeholder shuttle diplomacy for when you're facing HiPPOs, RHiNOs, and WoLFs (oh my!).
• Pricing for Product Managers - Value-based pricing, packaging strategy, price increases, and grandfather clause negotiations without the panic spiral and flop sweat.
• Classic Business Strategy Frameworks - Ansoff, BCG, Porter's 5 Forces, Blue Ocean, and SWOT in agent-ready format that helps you decide, not decorate slides.
• Storytelling for Product Managers - Narrative arc, demo choreography, and pitch structure built on pro-opera lessons and Hakawati orations for commanding the room.
• Prompt Building for Product Managers - Industrial-strength prompt engineering: team session starters, multi-turn workflow wizards, and reverse engineering templates for artifacts like PRDs.
• Nightmares of Product Management - Telemetry, triage, and tactics for when things don't go as planned: adoption theater, feature graveyards, metric manipulation, launch amnesia, technical debt wildfires. Plus prevention strategies.

Detailed concept notes live in PLANS.md.

Confused by setup options? Start here: PM Skills Rule-of-Thumb Guide.

# Skill mode
./scripts/run-pm.sh skill user-story "Checkout improvements for returning customers"

# Command mode
./scripts/run-pm.sh command plan-roadmap "Q3-Q4 roadmap for enterprise reporting"

Command definitions live in commands/, and generated browse indexes live in catalog/.

1. Open a conversation with Claude
2. Share the skill file: "Read user-story.md"
3. Ask Claude to apply it: "Using the User Story skill, write stories for our checkout flow"

cd product-manager-skills
claude "Using the PRD Development workflow, create a PRD for our mobile feature"

You can discover via npx skills find <query> and npx skills add deanpeters/Product-Manager-Skills --list, then install for Claude Code. See Using PM Skills with Claude.

Use local workspace paths, GitHub-connected Codex on ChatGPT, or discover/install directly with npx skills. See Using PM Skills with Codex.

Use GitHub app connections (formerly connectors), Custom GPT Knowledge uploads, or Project files. See Using PM Skills with ChatGPT.

Cowork: Import skills as knowledge modules, invoke via natural language. Other agents: Follow your agent's docs for loading custom knowledge.

• Using PM Skills 101 — Beginner-friendly orientation for PMs who want clear setup without technical overload.
• Using PM Skills with Claude — Claude Code usage plus GitHub ZIP upload steps for Claude Desktop/Web.
• Using PM Skills with Codex — Local workspace usage plus GitHub-connected Codex on ChatGPT.
• Using PM Skills with ChatGPT — GitHub app connection, Custom GPT Knowledge setup, and Project-based usage.
• Platform Guides for PMs — Tool-by-tool setup chooser for Claude Code, Codex, OpenClaw, Cowork, Claude Desktop, ChatGPT Desktop, n8n, LangFlow, and Python agents.
• Using PM Skills with Claude Code — PM-focused quickstart for Claude Code users.
• Using PM Skills with Slash Commands 101 — Turn PM skills into reusable Claude slash commands like /pm-story and /pm-prd.
• Using PM Skills with Claude Desktop — Skill upload workflow for non-technical desktop users.
• Using PM Skills with ChatGPT Desktop — Project-first setup for desktop-based PM work.
• Using PM Skills with n8n — Practical automation patterns for repeatable PM workflows.
• Using PM Skills with LangFlow — Visual workflow setup using skill-guided prompt templates.
• Additional harness guides: Cursor, Windsurf, Bolt, Replit Agent, Make.com, Devin, CrewAI, Gemini
• Start Here — One-page "do this now" onboarding for skills and commands.
• Commands — Command format, command list, validation, and discovery.
• Catalog Artifacts — Generated skill/command indexes for fast navigation.
• PM Skills Rule-of-Thumb Guide — Non-technical setup choices (local repo vs ZIP vs app connections) in plain English.
• Marketplace Strategy — PM-friendly strategy for distributing skills in marketplaces.
• Marketplace Submission Runbook — Step-by-step submission workflow for non-technical teams.
• Marketplace Issue Templates — Reusable issue templates for marketplace execution and tracking.
• PM Tooling Operations Charter — Pedagogic operating stack across M365 Copilot, Codex, ChatGPT, VS Code/Copilot, Cursor, n8n, and Lovable.
• Add-a-Skill Utility Guide — End-to-end automation guide for generating and validating new skills.
• Building PM Skills — How we distill sources into agent-ready PM skills.

→ Workflow: product-strategy-session (2-4 weeks, orchestrates positioning → roadmap)

→ Workflow: discovery-process (3-4 weeks, interviews → synthesis → validation)

→ Interactive: pol-probe-advisor (recommends which prototype type: Feasibility, Task-Focused, Narrative, Synthetic Data, or Vibe-Coded) → Component: pol-probe (template for documenting validation experiments)

→ Interactive: ai-shaped-readiness-advisor (assesses 5 competencies: Context Design, Agent Orchestration, Outcome Acceleration, Team-AI Facilitation, Strategic Differentiation)

→ Interactive: context-engineering-advisor (diagnose context stuffing vs. engineering, define boundaries, implement Research→Plan→Reset→Implement cycle)

→ Workflow: prd-development (2-4 days, problem → solution → stories)

→ Workflow: roadmap-planning (1-2 weeks, epics → prioritization → sequencing)

→ Interactive: prioritization-advisor (asks questions, recommends RICE/ICE/Kano)

→ Interactive: epic-breakdown-advisor (Richard Lawrence's 9 patterns)

→ Component: user-story (template + examples)

Skills = Less explaining, more strategic work.

Built on proven methods from Geoffrey Moore, Jeff Patton, Teresa Torres, Amazon, Richard Lawrence, MITRE, and more.

Based on decades of PM consulting across healthcare, finance, manufacturing, and tech.

Optimized for AI comprehension—not blog posts, not books, not courses. Executable frameworks.

Every word earns its keep. No filler, no buzzwords, no generic advice.

Shows both "good" and "bad" examples so you know what works and what to avoid.

Every skill follows the same format:

## Purpose
What this skill does and when to use it.

## Key Concepts
Core frameworks, definitions, anti-patterns.

## Application
Step-by-step instructions (with examples).

## Examples
Real-world cases (good and bad).

## Common Pitfalls
What to avoid and why.

## References
Related skills and external frameworks.

Clean. Practical. Zero fluff.

Found a gap? Have a PM framework you'd like to see included?

Ways to contribute:

• Open an issue with your suggestion
• Submit a pull request (we'll help you format it)
• Share feedback on what's working or missing

See CONTRIBUTING.md for detailed guidelines.

Principles:

• Outcome-driven over output-driven (solve problems, don't just ship features)
• Evidence over vibes (validate with data, not opinions)
• Clarity beats completeness (simple and usable beats comprehensive and confusing)
• Examples beat explanations (show, don't just tell)

No hype. No buzzwords. Just frameworks that work.

• Product Manager Prompts — Task-specific prompts for ChatGPT, Claude, Gemini
• Productside — AI-powered product management training and consulting
• Dean's LinkedIn — Essays on AI-amplified product work

CC BY-NC-SA 4.0 — non-commercial use with share-alike.

See LICENSE for full details.

• GitHub Issues: Report bugs or suggest features
• LinkedIn: Connect with Dean Peters
• Productside: Learn more about AI PM consulting

v0.7 — March 9, 2026

Highlights in this release:

• Tightened skill descriptions so they communicate both what the skill does and when to use it
• Added intent as a repo-standard frontmatter field to separate trigger metadata from deeper purpose
• Added scripts/check-skill-triggers.py and wired trigger-readiness auditing into test-library.sh
• Added find-a-skill.sh --mode trigger so users can discover skills through description, best_for, and scenarios
• Added a Streamlit (beta) Find My Skill mode with plain-English discovery, recommended-first results, and direct preview/run actions
• Updated authoring docs and templates so the stronger metadata standard sticks

v0.65 — March 8, 2026

Highlights in this release:

• Added comprehensive PM-first onboarding and setup guide: docs/Using PM Skills 101.md
• Added platform chooser: docs/Platform Guides for PMs.md
• Added slash-command playbook: docs/Using PM Skills with Slash Commands 101.md
• Added and linked practical platform docs for Claude Code/Desktop/Cowork, ChatGPT Desktop, OpenClaw, n8n, LangFlow, and Python agents
• Updated START_HERE.md and docs navigation so new users can pick the right setup path faster

v0.6 — March 6, 2026

Highlights in this release:

• Added commands/ with reusable workflow wrappers over local skills (discover, strategy, write-prd, plan-roadmap, prioritize, leadership-transition)
• Added START_HERE.md for 60-second onboarding
• Added generated catalog/ artifacts for fast skill and command navigation
• Added tooling for discovery/validation/execution: find-a-command.sh, run-pm.sh, check-command-metadata.py, test-library.sh, generate-catalog.py

v0.5 — February 27, 2026

Highlights in this release:

• Added 4 Career & Leadership skills distilled from The Product Porch episodes on PM→Director and Director→VP/CPO transitions
• Launched Streamlit (beta) local playground in app/ with multi-provider/model selection
• Improved workflow UX in beta app: phase detection, explicit run controls, and per-phase output tracking

v0.4 — February 10, 2026

Highlights in this release:

• Fixed a facilitation protocol regression where brevity-focused rewrites could remove expected guided-question behavior
• Promoted workshop-facilitation to canonical source of truth for interactive facilitation
• Added consistent opening heads-up, context-dump bypass path, and best-guess mode
• Applied protocol linkage across interactive skills and facilitation-heavy workflow skills

v0.3 — February 9, 2026

Highlights in this release:

• 42 total skills, including Phase 7 finance skills and the new skill-authoring-workflow
• New skill tooling: add-a-skill, build-a-skill, find-a-skill, test-a-skill, zip-a-skill
• New onboarding docs for Claude, Codex, ChatGPT, and non-technical "rule-of-thumb" setup

Built by Dean Peters (Principal Consultant and Trainer at Productside.com) with Anthropic Claude and OpenAI Codex.

Helping product managers work smarter with AI.