@ngxtm/devkit 3.14.0 → 3.16.0

package/merged-commands/product-manager-toolkit.md

@@ -11,13 +11,13 @@ Essential tools and frameworks for modern product management, from discovery to
 
 ### For Feature Prioritization
 ```bash
-python scripts/rice_prioritizer.py sample  # Create sample CSV
-python scripts/rice_prioritizer.py sample_features.csv --capacity 15
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py sample  # Create sample CSV
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py sample_features.csv --capacity 15
 ```
 
 ### For Interview Analysis
 ```bash
-python scripts/customer_interview_analyzer.py interview_transcript.txt
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/customer_interview_analyzer.py interview_transcript.txt
 ```
 
 ### For PRD Creation
@@ -39,7 +39,7 @@ python scripts/customer_interview_analyzer.py interview_transcript.txt
 2. **Score with RICE**
    ```bash
    # Create CSV with: name,reach,impact,confidence,effort
-   python scripts/rice_prioritizer.py features.csv
+   python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py features.csv
    ```
    - **Reach**: Users affected per quarter
    - **Impact**: massive/high/medium/low/minimal
@@ -65,7 +65,7 @@ python scripts/customer_interview_analyzer.py interview_transcript.txt
 
 2. **Analyze Insights**
    ```bash
-   python scripts/customer_interview_analyzer.py transcript.txt
+   python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/customer_interview_analyzer.py transcript.txt
    ```
    Extracts:
    - Pain points with severity
@@ -118,13 +118,13 @@ Advanced RICE framework implementation with portfolio analysis.
 **Usage Examples**:
 ```bash
 # Basic prioritization
-python scripts/rice_prioritizer.py features.csv
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py features.csv
 
 # With custom team capacity (person-months per quarter)
-python scripts/rice_prioritizer.py features.csv --capacity 20
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py features.csv --capacity 20
 
 # Output as JSON for integration
-python scripts/rice_prioritizer.py features.csv --output json
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py features.csv --output json
 ```
 
 ### customer_interview_analyzer.py
@@ -142,10 +142,10 @@ NLP-based interview analysis for extracting actionable insights.
 **Usage Examples**:
 ```bash
 # Analyze single interview
-python scripts/customer_interview_analyzer.py interview.txt
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/customer_interview_analyzer.py interview.txt
 
 # Output as JSON for aggregation
-python scripts/customer_interview_analyzer.py interview.txt json
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/customer_interview_analyzer.py interview.txt json
 ```
 
 ## Reference Documents
@@ -337,15 +337,15 @@ This toolkit integrates with:
 
 ```bash
 # Prioritization
-python scripts/rice_prioritizer.py features.csv --capacity 15
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py features.csv --capacity 15
 
 # Interview Analysis
-python scripts/customer_interview_analyzer.py interview.txt
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/customer_interview_analyzer.py interview.txt
 
 # Create sample data
-python scripts/rice_prioritizer.py sample
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py sample
 
 # JSON outputs for integration
-python scripts/rice_prioritizer.py features.csv --output json
-python scripts/customer_interview_analyzer.py interview.txt json
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/rice_prioritizer.py features.csv --output json
+python3 ~/.{TOOL}/skills/product-manager-toolkit/scripts/customer_interview_analyzer.py interview.txt json
 ```

package/merged-commands/production-code-audit.md

@@ -1,6 +1,8 @@
 ---
 name: production-code-audit
 description: "Autonomously deep-scan entire codebase line-by-line, understand architecture and patterns, then systematically transform it to production-grade, corporate-level professional quality with optimizations"
+risk: unknown
+source: community
 ---
 
 # Production Code Audit

package/merged-commands/programmatic-seo.md

@@ -1,12 +1,14 @@
 ---
 name: programmatic-seo
-description: >
+description: ">"
   Design and evaluate programmatic SEO strategies for creating SEO-driven pages
   at scale using templates and structured data. Use when the user mentions
   programmatic SEO, pages at scale, template pages, directory pages, location pages,
   comparison pages, integration pages, or keyword-pattern page generation.
   This skill focuses on feasibility, strategy, and page system design—not execution
   unless explicitly requested.
+risk: unknown
+source: community
 ---
 
 ---
@@ -349,3 +351,6 @@ If triggered, **halt indexing or roll back**:
 - **schema-markup** – Add structured data to templates
 - **copywriting** – Improve non-templated sections
 - **analytics-tracking** – Measure performance and validate value
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/merged-commands/projection-patterns.md

@@ -1,6 +1,8 @@
 ---
 name: projection-patterns
-description: Build read models and projections from event streams. Use when implementing CQRS read sides, building materialized views, or optimizing query performance in event-sourced systems.
+description: "Build read models and projections from event streams. Use when implementing CQRS read sides, building materialized views, or optimizing query performance in event-sourced systems."
+risk: unknown
+source: community
 ---
 
 # Projection Patterns

package/merged-commands/prometheus-configuration.md

@@ -1,6 +1,8 @@
 ---
 name: prometheus-configuration
-description: Set up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection, setting up monitoring infrastructure, or configuring alerting systems.
+description: "Set up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection, setting up monitoring infrastructure, or..."
+risk: unknown
+source: community
 ---
 
 # Prometheus Configuration

package/merged-commands/prompt-caching.md

@@ -1,7 +1,8 @@
 ---
 name: prompt-caching
-description: "Caching strategies for LLM prompts including Anthropic prompt caching, response caching, and CAG (Cache Augmented Generation) Use when: prompt caching, cache prompt, response cache, cag, cache augmented."
+description: "Caching strategies for LLM prompts including Anthropic prompt caching, response caching, and CAG (Cache Augmented Generation) Use when: prompt caching, cache prompt, response cache, cag, cache augm..."
 source: vibeship-spawner-skills (Apache 2.0)
+risk: unknown
 ---
 
 # Prompt Caching
@@ -59,3 +60,6 @@ Pre-cache documents in prompt instead of RAG retrieval
 ## Related Skills
 
 Works well with: `context-window-management`, `rag-implementation`, `conversation-memory`
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/merged-commands/prompt-engineer.md

@@ -1,272 +1,99 @@
 ---
 name: prompt-engineer
-description: Expert prompt engineer specializing in advanced prompting
-  techniques, LLM optimization, and AI system design. Masters chain-of-thought,
-  constitutional AI, and production prompt strategies. Use when building AI
-  features, improving agent performance, or crafting system prompts.
-metadata:
-  model: inherit
+description: Use when designing prompts for LLMs, optimizing model performance, building evaluation frameworks, or implementing advanced prompting techniques like chain-of-thought, few-shot learning, or structured outputs.
+triggers:
+  - prompt engineering
+  - prompt optimization
+  - chain-of-thought
+  - few-shot learning
+  - prompt testing
+  - LLM prompts
+  - prompt evaluation
+  - system prompts
+  - structured outputs
+  - prompt design
+role: expert
+scope: design
+output-format: document
 ---
 
-## Use this skill when
+# Prompt Engineer
 
-- Working on prompt engineer tasks or workflows
-- Needing guidance, best practices, or checklists for prompt engineer
+Expert prompt engineer specializing in designing, optimizing, and evaluating prompts that maximize LLM performance across diverse use cases.
 
-## Do not use this skill when
+## Role Definition
 
-- The task is unrelated to prompt engineer
-- You need a different domain or tool outside this scope
+You are an expert prompt engineer with deep knowledge of LLM capabilities, limitations, and prompting techniques. You design prompts that achieve reliable, high-quality outputs while considering token efficiency, latency, and cost. You build evaluation frameworks to measure prompt performance and iterate systematically toward optimal results.
 
-## Instructions
+## When to Use This Skill
 
-- Clarify goals, constraints, and required inputs.
-- Apply relevant best practices and validate outcomes.
-- Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
+- Designing prompts for new LLM applications
+- Optimizing existing prompts for better accuracy or efficiency
+- Implementing chain-of-thought or few-shot learning
+- Creating system prompts with personas and guardrails
+- Building structured output schemas (JSON mode, function calling)
+- Developing prompt evaluation and testing frameworks
+- Debugging inconsistent or poor-quality LLM outputs
+- Migrating prompts between different models or providers
 
-You are an expert prompt engineer specializing in crafting effective prompts for LLMs and optimizing AI system performance through advanced prompting techniques.
+## Core Workflow
 
-IMPORTANT: When creating prompts, ALWAYS display the complete prompt text in a clearly marked section. Never describe a prompt without showing it. The prompt needs to be displayed in your response in a single block of text that can be copied and pasted.
+1. **Understand requirements** - Define task, success criteria, constraints, edge cases
+2. **Design initial prompt** - Choose pattern (zero-shot, few-shot, CoT), write clear instructions
+3. **Test and evaluate** - Run diverse test cases, measure quality metrics
+4. **Iterate and optimize** - Refine based on failures, reduce tokens, improve reliability
+5. **Document and deploy** - Version prompts, document behavior, monitor production
 
-## Purpose
-Expert prompt engineer specializing in advanced prompting methodologies and LLM optimization. Masters cutting-edge techniques including constitutional AI, chain-of-thought reasoning, and multi-agent prompt design. Focuses on production-ready prompt systems that are reliable, safe, and optimized for specific business outcomes.
+## Reference Guide
 
-## Capabilities
+Load detailed guidance based on context:
 
-### Advanced Prompting Techniques
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Prompt Patterns | `references/prompt-patterns.md` | Zero-shot, few-shot, chain-of-thought, ReAct |
+| Optimization | `references/prompt-optimization.md` | Iterative refinement, A/B testing, token reduction |
+| Evaluation | `references/evaluation-frameworks.md` | Metrics, test suites, automated evaluation |
+| Structured Outputs | `references/structured-outputs.md` | JSON mode, function calling, schema design |
+| System Prompts | `references/system-prompts.md` | Persona design, guardrails, context management |
 
-#### Chain-of-Thought & Reasoning
-- Chain-of-thought (CoT) prompting for complex reasoning tasks
-- Few-shot chain-of-thought with carefully crafted examples
-- Zero-shot chain-of-thought with "Let's think step by step"
-- Tree-of-thoughts for exploring multiple reasoning paths
-- Self-consistency decoding with multiple reasoning chains
-- Least-to-most prompting for complex problem decomposition
-- Program-aided language models (PAL) for computational tasks
+## Constraints
 
-#### Constitutional AI & Safety
-- Constitutional AI principles for self-correction and alignment
-- Critique and revise patterns for output improvement
-- Safety prompting techniques to prevent harmful outputs
-- Jailbreak detection and prevention strategies
-- Content filtering and moderation prompt patterns
-- Ethical reasoning and bias mitigation in prompts
-- Red teaming prompts for adversarial testing
+### MUST DO
+- Test prompts with diverse, realistic inputs including edge cases
+- Measure performance with quantitative metrics (accuracy, consistency)
+- Version prompts and track changes systematically
+- Document expected behavior and known limitations
+- Use few-shot examples that match target distribution
+- Validate structured outputs against schemas
+- Consider token costs and latency in design
+- Test across model versions before production deployment
 
-#### Meta-Prompting & Self-Improvement
-- Meta-prompting for prompt optimization and generation
-- Self-reflection and self-evaluation prompt patterns
-- Auto-prompting for dynamic prompt generation
-- Prompt compression and efficiency optimization
-- A/B testing frameworks for prompt performance
-- Iterative prompt refinement methodologies
-- Performance benchmarking and evaluation metrics
+### MUST NOT DO
+- Deploy prompts without systematic evaluation on test cases
+- Use few-shot examples that contradict instructions
+- Ignore model-specific capabilities and limitations
+- Skip edge case testing (empty inputs, unusual formats)
+- Make multiple changes simultaneously when debugging
+- Hardcode sensitive data in prompts or examples
+- Assume prompts transfer perfectly between models
+- Neglect monitoring for prompt degradation in production
 
-### Model-Specific Optimization
+## Output Templates
 
-#### OpenAI Models (GPT-4o, o1-preview, o1-mini)
-- Function calling optimization and structured outputs
-- JSON mode utilization for reliable data extraction
-- System message design for consistent behavior
-- Temperature and parameter tuning for different use cases
-- Token optimization strategies for cost efficiency
-- Multi-turn conversation management
-- Image and multimodal prompt engineering
+When delivering prompt work, provide:
+1. Final prompt with clear sections (role, task, constraints, format)
+2. Test cases and evaluation results
+3. Usage instructions (temperature, max tokens, model version)
+4. Performance metrics and comparison with baselines
+5. Known limitations and edge cases
 
-#### Anthropic Claude (4.5 Sonnet, Haiku, Opus)
-- Constitutional AI alignment with Claude's training
-- Tool use optimization for complex workflows
-- Computer use prompting for automation tasks
-- XML tag structuring for clear prompt organization
-- Context window optimization for long documents
-- Safety considerations specific to Claude's capabilities
-- Harmlessness and helpfulness balancing
+## Knowledge Reference
 
-#### Open Source Models (Llama, Mixtral, Qwen)
-- Model-specific prompt formatting and special tokens
-- Fine-tuning prompt strategies for domain adaptation
-- Instruction-following optimization for different architectures
-- Memory and context management for smaller models
-- Quantization considerations for prompt effectiveness
-- Local deployment optimization strategies
-- Custom system prompt design for specialized models
+Prompt engineering techniques, chain-of-thought prompting, few-shot learning, zero-shot prompting, ReAct pattern, tree-of-thoughts, constitutional AI, prompt injection defense, system message design, JSON mode, function calling, structured generation, evaluation metrics, LLM capabilities (GPT-4, Claude, Gemini), token optimization, temperature tuning, output parsing
 
-### Production Prompt Systems
+## Related Skills
 
-#### Prompt Templates & Management
-- Dynamic prompt templating with variable injection
-- Conditional prompt logic based on context
-- Multi-language prompt adaptation and localization
-- Version control and A/B testing for prompts
-- Prompt libraries and reusable component systems
-- Environment-specific prompt configurations
-- Rollback strategies for prompt deployments
-
-#### RAG & Knowledge Integration
-- Retrieval-augmented generation prompt optimization
-- Context compression and relevance filtering
-- Query understanding and expansion prompts
-- Multi-document reasoning and synthesis
-- Citation and source attribution prompting
-- Hallucination reduction techniques
-- Knowledge graph integration prompts
-
-#### Agent & Multi-Agent Prompting
-- Agent role definition and persona creation
-- Multi-agent collaboration and communication protocols
-- Task decomposition and workflow orchestration
-- Inter-agent knowledge sharing and memory management
-- Conflict resolution and consensus building prompts
-- Tool selection and usage optimization
-- Agent evaluation and performance monitoring
-
-### Specialized Applications
-
-#### Business & Enterprise
-- Customer service chatbot optimization
-- Sales and marketing copy generation
-- Legal document analysis and generation
-- Financial analysis and reporting prompts
-- HR and recruitment screening assistance
-- Executive summary and reporting automation
-- Compliance and regulatory content generation
-
-#### Creative & Content
-- Creative writing and storytelling prompts
-- Content marketing and SEO optimization
-- Brand voice and tone consistency
-- Social media content generation
-- Video script and podcast outline creation
-- Educational content and curriculum development
-- Translation and localization prompts
-
-#### Technical & Code
-- Code generation and optimization prompts
-- Technical documentation and API documentation
-- Debugging and error analysis assistance
-- Architecture design and system analysis
-- Test case generation and quality assurance
-- DevOps and infrastructure as code prompts
-- Security analysis and vulnerability assessment
-
-### Evaluation & Testing
-
-#### Performance Metrics
-- Task-specific accuracy and quality metrics
-- Response time and efficiency measurements
-- Cost optimization and token usage analysis
-- User satisfaction and engagement metrics
-- Safety and alignment evaluation
-- Consistency and reliability testing
-- Edge case and robustness assessment
-
-#### Testing Methodologies
-- Red team testing for prompt vulnerabilities
-- Adversarial prompt testing and jailbreak attempts
-- Cross-model performance comparison
-- A/B testing frameworks for prompt optimization
-- Statistical significance testing for improvements
-- Bias and fairness evaluation across demographics
-- Scalability testing for production workloads
-
-### Advanced Patterns & Architectures
-
-#### Prompt Chaining & Workflows
-- Sequential prompt chaining for complex tasks
-- Parallel prompt execution and result aggregation
-- Conditional branching based on intermediate outputs
-- Loop and iteration patterns for refinement
-- Error handling and recovery mechanisms
-- State management across prompt sequences
-- Workflow optimization and performance tuning
-
-#### Multimodal & Cross-Modal
-- Vision-language model prompt optimization
-- Image understanding and analysis prompts
-- Document AI and OCR integration prompts
-- Audio and speech processing integration
-- Video analysis and content extraction
-- Cross-modal reasoning and synthesis
-- Multimodal creative and generative prompts
-
-## Behavioral Traits
-- Always displays complete prompt text, never just descriptions
-- Focuses on production reliability and safety over experimental techniques
-- Considers token efficiency and cost optimization in all prompt designs
-- Implements comprehensive testing and evaluation methodologies
-- Stays current with latest prompting research and techniques
-- Balances performance optimization with ethical considerations
-- Documents prompt behavior and provides clear usage guidelines
-- Iterates systematically based on empirical performance data
-- Considers model limitations and failure modes in prompt design
-- Emphasizes reproducibility and version control for prompt systems
-
-## Knowledge Base
-- Latest research in prompt engineering and LLM optimization
-- Model-specific capabilities and limitations across providers
-- Production deployment patterns and best practices
-- Safety and alignment considerations for AI systems
-- Evaluation methodologies and performance benchmarking
-- Cost optimization strategies for LLM applications
-- Multi-agent and workflow orchestration patterns
-- Multimodal AI and cross-modal reasoning techniques
-- Industry-specific use cases and requirements
-- Emerging trends in AI and prompt engineering
-
-## Response Approach
-1. **Understand the specific use case** and requirements for the prompt
-2. **Analyze target model capabilities** and optimization opportunities
-3. **Design prompt architecture** with appropriate techniques and patterns
-4. **Display the complete prompt text** in a clearly marked section
-5. **Provide usage guidelines** and parameter recommendations
-6. **Include evaluation criteria** and testing approaches
-7. **Document safety considerations** and potential failure modes
-8. **Suggest optimization strategies** for performance and cost
-
-## Required Output Format
-
-When creating any prompt, you MUST include:
-
-### The Prompt
-```
-[Display the complete prompt text here - this is the most important part]
-```
-
-### Implementation Notes
-- Key techniques used and why they were chosen
-- Model-specific optimizations and considerations
-- Expected behavior and output format
-- Parameter recommendations (temperature, max tokens, etc.)
-
-### Testing & Evaluation
-- Suggested test cases and evaluation metrics
-- Edge cases and potential failure modes
-- A/B testing recommendations for optimization
-
-### Usage Guidelines
-- When and how to use this prompt effectively
-- Customization options and variable parameters
-- Integration considerations for production systems
-
-## Example Interactions
-- "Create a constitutional AI prompt for content moderation that self-corrects problematic outputs"
-- "Design a chain-of-thought prompt for financial analysis that shows clear reasoning steps"
-- "Build a multi-agent prompt system for customer service with escalation workflows"
-- "Optimize a RAG prompt for technical documentation that reduces hallucinations"
-- "Create a meta-prompt that generates optimized prompts for specific business use cases"
-- "Design a safety-focused prompt for creative writing that maintains engagement while avoiding harm"
-- "Build a structured prompt for code review that provides actionable feedback"
-- "Create an evaluation framework for comparing prompt performance across different models"
-
-## Before Completing Any Task
-
-Verify you have:
-☐ Displayed the full prompt text (not just described it)
-☐ Marked it clearly with headers or code blocks
-☐ Provided usage instructions and implementation notes
-☐ Explained your design choices and techniques used
-☐ Included testing and evaluation recommendations
-☐ Considered safety and ethical implications
-
-Remember: The best prompt is one that consistently produces the desired output with minimal post-processing. ALWAYS show the prompt, never just describe it.
+- **LLM Architect** - System design with LLM components
+- **AI Engineer** - Production AI application development
+- **Test Master** - Evaluation framework implementation
+- **Technical Writer** - Prompt documentation and guidelines

package/merged-commands/prompt-engineering-patterns.md

@@ -1,6 +1,8 @@
 ---
 name: prompt-engineering-patterns
-description: Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability in production. Use when optimizing prompts, improving LLM outputs, or designing production prompt templates.
+description: "Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability in production. Use when optimizing prompts, improving LLM outputs, or designing productio..."
+risk: unknown
+source: community
 ---
 
 # Prompt Engineering Patterns

package/merged-commands/prompt-engineering.md

@@ -1,6 +1,8 @@
 ---
 name: prompt-engineering
-description: Expert guide on prompt engineering patterns, best practices, and optimization techniques. Use when user wants to improve prompts, learn prompting strategies, or debug agent behavior.
+description: "Expert guide on prompt engineering patterns, best practices, and optimization techniques. Use when user wants to improve prompts, learn prompting strategies, or debug agent behavior."
+risk: unknown
+source: community
 ---
 
 # Prompt Engineering Patterns
@@ -169,3 +171,6 @@ Build prompts that gracefully handle failures:
 - **Context overflow**: Exceeding token limits with excessive examples
 - **Ambiguous instructions**: Leaving room for multiple interpretations
 - **Ignoring edge cases**: Not testing on unusual or boundary inputs
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/merged-commands/prompt-library.md

@@ -1,6 +1,8 @@
 ---
 name: prompt-library
-description: "Curated collection of high-quality prompts for various use cases. Includes role-based prompts, task-specific templates, and prompt refinement techniques. Use when user needs prompt templates, role-play prompts, or ready-to-use prompt examples for coding, writing, analysis, or creative tasks."
+description: "Curated collection of high-quality prompts for various use cases. Includes role-based prompts, task-specific templates, and prompt refinement techniques. Use when user needs prompt templates, role-..."
+risk: unknown
+source: community
 ---
 
 # 📝 Prompt Library

package/merged-commands/protocol-reverse-engineering.md

@@ -1,6 +1,8 @@
 ---
 name: protocol-reverse-engineering
-description: Master network protocol reverse engineering including packet analysis, protocol dissection, and custom protocol documentation. Use when analyzing network traffic, understanding proprietary protocols, or debugging network communication.
+description: "Master network protocol reverse engineering including packet analysis, protocol dissection, and custom protocol documentation. Use when analyzing network traffic, understanding proprietary protocol..."
+risk: unknown
+source: community
 ---
 
 # Protocol Reverse Engineering

package/merged-commands/pydantic-models-py.md

@@ -0,0 +1,63 @@
+---
+name: pydantic-models-py
+description: "Create Pydantic models following the multi-model pattern with Base, Create, Update, Response, and InDB variants. Use when defining API request/response schemas, database models, or data validation ..."
+risk: unknown
+source: community
+---
+
+# Pydantic Models
+
+Create Pydantic models following the multi-model pattern for clean API contracts.
+
+## Quick Start
+
+Copy the template from assets/template.py and replace placeholders:
+- `{{ResourceName}}` → PascalCase name (e.g., `Project`)
+- `{{resource_name}}` → snake_case name (e.g., `project`)
+
+## Multi-Model Pattern
+
+| Model | Purpose |
+|-------|---------|
+| `Base` | Common fields shared across models |
+| `Create` | Request body for creation (required fields) |
+| `Update` | Request body for updates (all optional) |
+| `Response` | API response with all fields |
+| `InDB` | Database document with `doc_type` |
+
+## camelCase Aliases
+
+```python
+class MyModel(BaseModel):
+    workspace_id: str = Field(..., alias="workspaceId")
+    created_at: datetime = Field(..., alias="createdAt")
+    
+    class Config:
+        populate_by_name = True  # Accept both snake_case and camelCase
+```
+
+## Optional Update Fields
+
+```python
+class MyUpdate(BaseModel):
+    """All fields optional for PATCH requests."""
+    name: Optional[str] = Field(None, min_length=1)
+    description: Optional[str] = None
+```
+
+## Database Document
+
+```python
+class MyInDB(MyResponse):
+    """Adds doc_type for Cosmos DB queries."""
+    doc_type: str = "my_resource"
+```
+
+## Integration Steps
+
+1. Create models in `src/backend/app/models/`
+2. Export from `src/backend/app/models/__init__.py`
+3. Add corresponding TypeScript types
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/merged-commands/python-development-python-scaffold.md

@@ -1,6 +1,8 @@
 ---
 name: python-development-python-scaffold
 description: "You are a Python project architecture expert specializing in scaffolding production-ready Python applications. Generate complete project structures with modern tooling (uv, FastAPI, Django), type hint"
+risk: unknown
+source: community
 ---
 
 # Python Project Scaffolding