product-capability

Translate product intent into engineering constraints and implementation-ready capability plans.

Updated Jan 30, 2026
One-click install
npx skills add https://github.com/ThejanaJayalath/Niolla-PM-system --skill product-capability-thejanajayalath
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: product-capability
Source: https://github.com/ThejanaJayalath/Niolla-PM-system/tree/main/.cursor/.agents/skills/product-capability
Command: npx skills add https://github.com/ThejanaJayalath/Niolla-PM-system --skill product-capability-thejanajayalath

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill bridges the gap between high-level product requirements and technical implementation by identifying hidden constraints, architectural invariants, and unresolved decisions before coding begins.

Core Features & Use Cases

  • Constraint Extraction: Identifies business rules, trust boundaries, and data ownership requirements from vague product notes.
  • Implementation Contract: Generates an SRS-style plan detailing actors, surfaces, and state transitions.
  • Use Case: When a new feature spans multiple services, use this skill to define the capability contract, ensuring all teams align on the implementation constraints before development starts.

Quick Start

Use the product-capability skill to analyze the provided PRD and generate an implementation contract for the new feature.

Frequently Asked Questions about product-capability

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I translate product intent into engineering constraints for a multi-service architecture?

To translate product intent into engineering constraints, define capability contracts that specify invariants, interfaces, and policy boundaries. This ensures multi-service architectures align with system-level implementation requirements before coding begins.

What is an implementation contract and when do I need one for product management?

An implementation contract is an SRS-style plan detailing actors, surfaces, and state transitions. You need one when a new feature spans multiple services and teams require durable technical artifacts to align product vision with implementation.

How do I extract architectural invariants and data ownership rules from vague product requirements?

Extract architectural invariants and data ownership rules by analyzing product notes to identify business rules, trust boundaries, and unresolved decisions. This constraint extraction process reveals hidden technical requirements before implementation starts.

Can I use capability planning to align multiple teams on complex feature development?

Yes, capability planning aligns multiple teams by generating explicit engineering constraints and implementation-ready plans. Defining policy boundaries and interfaces ensures all teams share a durable technical artifact for complex feature development.

What is the best way to define interfaces and state transitions for multi-service feature development?

The best way to define interfaces and state transitions is generating an SRS-style implementation contract. This document explicitly maps actors, surfaces, and state transitions to satisfy system-level implementation requirements across services.

When should I not use capability planning for product roadmap requirements?

Avoid capability planning for simple, single-service features that do not require multi-service architectural alignment. It is designed for complex feature development needing explicit invariants, trust boundaries, and policy definitions.