prompt-decorators / rules

---
description: APPLY software development decorators WHEN coding TO improve code quality and clarity
globs: *.py, *.js, *.ts, *.jsx, *.tsx, *.java, *.c, *.cpp, *.cs, *.go, *.rs, *.rb, *.php, *.swift
---

# Software Development Prompt Decorators

<version>1.0.0</version>

## Context
- Use these decorators when working on software development tasks
- Apply when generating code, designing systems, debugging issues, or reviewing code
- Use individually or combine multiple decorators for more specific results
- These decorators enhance the way the AI responds to coding-related requests

## Requirements
- Recognize and process all software development prompt decorators with the `+++` prefix
- Apply the appropriate transformation based on the decorator and its parameters
- Maintain the core query intent while applying decorator-specific modifications
- Support combinations of multiple decorators applied in sequence
- Follow the standard parameter parsing rules for all decorators

## Supported Decorators

### `+++Algorithm`
When this decorator is applied, the response implements specific algorithms with the desired complexity characteristics.

**Parameters:**
- `type (sorting | search | graph | string | numeric | ml | crypto)`: Algorithm category
- `complexity (constant | logarithmic | linear | linearithmic | quadratic | polynomial | exponential)`: Desired time complexity
- `approach (recursive | iterative | divide-conquer | dynamic | greedy)`: Algorithm design approach

**Example:**
```
+++Algorithm(type=graph, complexity=linear, approach=iterative)
Implement an algorithm to find the shortest path between two nodes in an unweighted graph.
```

### `+++APIDesign`
When this decorator is applied, the response designs API interfaces focusing on specific qualities.

**Parameters:**
- `style (rest | graphql | grpc | soap | websocket | webhook)`: API architectural style
- `focus (consistency | performance | developer-experience | backward-compatibility)`: Design priority
- `documentation (openapi | graphql-schema | protobuf | custom | style-appropriate)`: Documentation approach

**Example:**
```
+++APIDesign(style=graphql, focus=developer-experience, documentation=graphql-schema)
Design a GraphQL API for a content management system that prioritizes a great developer experience.
```

### `+++BugDiagnosis`
When this decorator is applied, the response systematically diagnoses software bugs using specified approaches.

**Parameters:**
- `method (bisection | logging | tracing | debugging | testing)`: Primary diagnostic method
- `level (symptoms | immediate-cause | root-cause)`: Depth of diagnosis
- `scope (code | configuration | environment | integration)`: Area to focus investigation

**Example:**
```
+++BugDiagnosis(method=bisection, level=root-cause, scope=integration)
Our login system intermittently fails when users attempt to authenticate with third-party providers.
```

### `+++CodeWalkthrough`
When this decorator is applied, the response provides a detailed explanation of code, following a specified pedagogical approach.

**Parameters:**
- `style (line-by-line | functional | conceptual | architectural)`: Explanation approach
- `audience (beginner | intermediate | advanced)`: Target knowledge level
- `highlight (patterns | gotchas | optimizations | all)`: Aspects to emphasize

**Example:**
```
+++CodeWalkthrough(style=functional, audience=intermediate, highlight=patterns)
Explain how this React component manages state and renders the UI.
```

### `+++DesignPattern`
When this decorator is applied, the response implements or explains software design patterns with appropriate applications.

**Parameters:**
- `pattern (singleton | factory | adapter | observer | strategy | command | facade)`: The design pattern to implement
- `language (python | javascript | typescript | java | csharp | go | rust)`: Programming language to use
- `variation (string)`: Specific variation of the pattern

**Example:**
```
+++DesignPattern(pattern=observer, language=javascript)
Create a notification system for an e-commerce application that alerts different parts of the UI when the cart changes.
```

### `+++TestCases`
When this decorator is applied, the response generates software test cases with specific coverage and methodologies.

**Parameters:**
- `type (unit | integration | functional | performance | security)`: Test category
- `coverage (happy-path | edge-cases | error-handling | all)`: Test coverage focus
- `framework (jest | pytest | junit | mocha | other)`: Testing framework to use

**Example:**
```
+++TestCases(type=unit, coverage=all, framework=pytest)
Write tests for this user authentication function.
```

### `+++SystemDiagram`
When this decorator is applied, the response creates a visual representation of system architecture or flow.

**Parameters:**
- `type (component | sequence | class | deployment | other)`: Diagram type
- `notation (uml | c4 | informal | boxes-arrows)`: Diagramming notation
- `detail (high-level | detailed)`: Level of detail to include

**Example:**
```
+++SystemDiagram(type=sequence, notation=uml, detail=detailed)
Create a diagram showing the authentication flow in our web application.
```

### `+++TechDebt`
When this decorator is applied, the response identifies and analyzes technical debt in code or architecture.

**Parameters:**
- `focus (code-quality | architecture | testing | documentation | other)`: Area of technical debt
- `severity (low | medium | high)`: How critical the tech debt is
- `remediation (quick-fixes | refactoring | redesign)`: Approach to addressing issues

**Example:**
```
+++TechDebt(focus=architecture, severity=high, remediation=refactoring)
Review our backend service that has evolved organically over three years with multiple contributors.
```

### `+++CICD`
When this decorator is applied, the response creates or explains continuous integration and deployment pipelines.

**Parameters:**
- `platform (github-actions | jenkins | gitlab-ci | circleci | azure-devops)`: CI/CD platform
- `stages (build | test | static-analysis | security | deploy | all)`: Pipeline stages to include
- `approach (basic | comprehensive)`: Level of sophistication

**Example:**
```
+++CICD(platform=github-actions, stages=all, approach=comprehensive)
Create a CI/CD pipeline for our Node.js backend application.
```

### `+++RootCauseAnalysis`
When this decorator is applied, the response performs a systematic analysis to identify underlying causes of a problem.

**Parameters:**
- `method (fivewhys | fishbone | pareto | fault-tree)`: The analytical method to use
- `depth (shallow | moderate | deep)`: How deeply to analyze the causes
- `focus (technical | process | organizational | all)`: Area to emphasize in analysis

**Example:**
```
+++RootCauseAnalysis(method=fivewhys, depth=deep, focus=technical)
Our application experiences intermittent performance degradation during peak usage hours.
```

### `+++OptimizationFocus`
When this decorator is applied, the response optimizes code or systems with emphasis on specific aspects.

**Parameters:**
- `goal (speed | memory | readability | scalability | security)`: Primary optimization target
- `constraints (time | resources | backward-compatibility | none)`: Limiting factors to consider
- `level (micro | architectural)`: Scope of optimization

**Example:**
```
+++OptimizationFocus(goal=speed, constraints=backward-compatibility, level=micro)
Improve the performance of this database query function that's causing a bottleneck.
```

### `+++ErrorStrategy`
When this decorator is applied, the response implements or suggests error handling approaches appropriate for the situation.

**Parameters:**
- `approach (defensive | exceptions | result-types | logging | recovery)`: Error handling paradigm
- `verbosity (minimal | informative | debug)`: Level of error information
- `user-facing (true | false)`: Whether errors should be user-presentable

**Example:**
```
+++ErrorStrategy(approach=result-types, verbosity=informative, user-facing=true)
Implement error handling for this API endpoint that processes user uploads.
```

### `+++Architecture`
When this decorator is applied, the response designs or analyzes software architecture with specific patterns and qualities.

**Parameters:**
- `style (microservices | monolith | serverless | event-driven | layered)`: Architecture pattern
- `focus (scalability | maintainability | performance | security | flexibility)`: Design priorities
- `constraints (budget | legacy | time | team-size | regulatory)`: Limiting factors

**Example:**
```
+++Architecture(style=microservices, focus=scalability, constraints=team-size)
Design a backend architecture for our e-commerce platform that needs to handle seasonal traffic spikes.
```

### `+++Documentation`
When this decorator is applied, the response creates software documentation following specified standards and formats.

**Parameters:**
- `type (api | code | user | architecture)`: Documentation category
- `format (markdown | javadoc | openapi | sphinx | other)`: Format standard
- `audience (developers | end-users | operations | managers)`: Target readers

**Example:**
```
+++Documentation(type=api, format=openapi, audience=developers)
Document our user authentication REST API.
```

### `+++BestPractices`
When this decorator is applied, the response explains or applies domain-specific best practices and standards.

**Parameters:**
- `domain (security | performance | maintainability | ux | accessibility)`: Practice area
- `context (web | mobile | enterprise | embedded | ml)`: Application context
- `level (basic | intermediate | advanced)`: Sophistication level

**Example:**
```
+++BestPractices(domain=security, context=web, level=advanced)
Review our user authentication and authorization implementation.
```

### `+++ImplementationStrategy`
When this decorator is applied, the response proposes systematic approaches to implementing a feature or system.

**Parameters:**
- `approach (incremental | mvp | prototype | vertical-slice | tdd)`: Implementation methodology
- `timeframe (immediate | short-term | long-term)`: Timing for completion
- `team (solo | small-team | large-team)`: Team resource context

**Example:**
```
+++ImplementationStrategy(approach=incremental, timeframe=short-term, team=small-team)
Plan the implementation of a new payment processing system for our e-commerce application.
```

### `+++DataModel`
When this decorator is applied, the response designs data models with appropriate structures and relationships.

**Parameters:**
- `type (relational | document | graph | time-series | key-value)`: Database paradigm
- `focus (normalization | performance | flexibility | integrity)`: Design priority
- `detail (conceptual | logical | physical)`: Level of modeling detail

**Example:**
```
+++DataModel(type=relational, focus=normalization, detail=logical)
Create a data model for an employee management system that tracks departments, positions, and reporting relationships.
```

### `+++SecurityAudit`
When this decorator is applied, the response analyzes code or architecture for security vulnerabilities.

**Parameters:**
- `focus (authentication | authorization | data-protection | input-validation | dependency)`: Security concern area
- `standard (owasp-top-10 | nist | cis | hipaa | pci-dss)`: Security standard reference
- `severity (low | medium | high | critical)`: Vulnerability level to identify

**Example:**
```
+++SecurityAudit(focus=input-validation, standard=owasp-top-10, severity=high)
Review our web form handling code for security vulnerabilities.
```

### `+++Refactor`
When this decorator is applied, the response improves existing code structure without changing its behavior.

**Parameters:**
- `goal (performance | readability | maintainability | security | testability)`: Primary objective of the refactoring
- `level (minor | moderate | major)`: Extent of changes to make
- `preserve (api | behavior | both)`: Aspects that must be preserved

**Example:**
```
+++Refactor(goal=performance, level=moderate, preserve=both)
Refactor this database query function that's causing performance issues.
```

### `+++CodeReview`
When this decorator is applied, the response provides feedback on code quality, following defined standards.

**Parameters:**
- `depth (quick | standard | thorough)`: Review comprehensiveness
- `focus (correctness | style | security | performance | all)`: Review emphasis
- `tone (strict | balanced | constructive)`: Feedback approach

**Example:**
```
+++CodeReview(depth=thorough, focus=security, tone=constructive)
Review this authentication middleware implementation for a Node.js application.
```

### `+++Monitoring`
When this decorator is applied, the response designs monitoring solutions for systems and applications.

**Parameters:**
- `metrics (performance | errors | usage | business | all)`: What to monitor
- `implementation (prometheus | cloudwatch | datadog | custom | other)`: Monitoring tools
- `alerts (none | minimal | comprehensive)`: Alert configuration level

**Example:**
```
+++Monitoring(metrics=all, implementation=prometheus, alerts=comprehensive)
Create a monitoring setup for our microservices architecture running on Kubernetes.
```

### `+++DebugStrategy`
When this decorator is applied, the response outlines a systematic approach to debugging and resolving issues.

**Parameters:**
- `approach (step-by-step | scientific | bisection | logging | profiling)`: Debugging methodology
- `tools (debugger | logs | metrics | traces | all)`: Debugging instruments
- `environment (development | staging | production)`: Context for debugging

**Example:**
```
+++DebugStrategy(approach=scientific, tools=all, environment=production)
Our payment processing service is intermittently failing during high traffic periods with no clear error pattern.
```

### `+++PullRequest`
When this decorator is applied, the response creates or reviews pull request documentation with appropriate detail.

**Parameters:**
- `type (creation | review | feedback)`: PR interaction type
- `scope (feature | bugfix | refactor | documentation)`: Change type
- `detail (minimal | standard | comprehensive)`: Information level

**Example:**
```
+++PullRequest(type=creation, scope=feature, detail=comprehensive)
Create a pull request description for my implementation of the new user profile management feature.
```

### `+++TypeDefinition`
When this decorator is applied, the response creates or explains type definitions with appropriate structures.

**Parameters:**
- `system (typescript | flow | jsdoc | python-typing | java-generics)`: Type system or annotation format
- `strictness (loose | moderate | strict)`: Level of type enforcement
- `style (inline | declaration-file | interface-based | type-alias | generics)`: Type definition pattern

**Example:**
```
+++TypeDefinition(system=typescript, strictness=strict, style=interface-based)
Define types for an e-commerce application's product catalog and shopping cart.
```

### `+++TaskBreakdown`
When this decorator is applied, the response decomposes complex tasks into manageable subtasks with clear organization.

**Parameters:**
- `structure (sequential | parallel | hierarchical)`: Task organization approach
- `granularity (coarse | medium | fine)`: Level of task decomposition
- `prioritization (must-have | nice-to-have | both)`: Task importance labeling

**Example:**
```
+++TaskBreakdown(structure=hierarchical, granularity=medium, prioritization=both)
Implement a new user authentication system with OAuth, multi-factor authentication, and password recovery.
```

### `+++PreciseModification`
When this decorator is applied, the response specifies code changes with exact locations and modifications.

**Parameters:**
- `scope (line | method | class | file)`: Modification granularity
- `approach (replace | insert | delete | modify)`: Change type
- `safety (minimal | defensive | comprehensive)`: Error prevention strategy

**Example:**
```
+++PreciseModification(scope=method, approach=modify, safety=comprehensive)
Fix the bug in our user registration method that allows duplicate email addresses.
```

### `+++DependencyAnalysis`
When this decorator is applied, the response analyzes software dependencies and their implications.

**Parameters:**
- `level (direct | transitive | all)`: Dependency depth to analyze
- `focus (security | compatibility | size | licensing)`: Analysis emphasis
- `action (report | upgrade | replace | optimize)`: Recommended next steps

**Example:**
```
+++DependencyAnalysis(level=all, focus=security, action=upgrade)
Analyze the npm dependencies in our Node.js application for security vulnerabilities.
```

### `+++EdgeCases`
When this decorator is applied, the response identifies and handles boundary conditions and unusual scenarios.

**Parameters:**
- `coverage (input | state | environment | all)`: Edge case categories
- `handling (validation | fallback | graceful-failure | prevention)`: Solution approach
- `documentation (none | code-comments | tests | comprehensive)`: How to document cases

**Example:**
```
+++EdgeCases(coverage=all, handling=validation, documentation=comprehensive)
Ensure this payment processing function handles all possible error conditions and edge cases.
```

### `+++AntiPatterns`
When this decorator is applied, the response identifies and remedies problematic coding or design patterns.

**Parameters:**
- `domain (architecture | code | database | concurrency | security)`: Problem area
- `severity (informational | concerning | critical)`: Issue importance
- `remediation (identify | explain | fix)`: Response approach

**Example:**
```
+++AntiPatterns(domain=code, severity=critical, remediation=fix)
Review this JavaScript code that manages asynchronous operations and user authentication.
```

### `+++ConceptModel`
When this decorator is applied, the response creates a conceptual model to explain complex technical topics.

**Parameters:**
- `abstraction (high | medium | detailed)`: Conceptual simplification level
- `format (analogy | diagram | narrative | comparison)`: Explanation approach
- `target (beginner | intermediate | expert)`: Audience knowledge level

**Example:**
```
+++ConceptModel(abstraction=medium, format=analogy, target=beginner)
Explain how containerization works and why it's useful for application deployment.
```

### `+++Compare`
When this decorator is applied, the response provides a systematic comparison between technical alternatives.

**Parameters:**
- `criteria (performance | cost | complexity | maturity | all)`: Comparison dimensions
- `format (table | pros-cons | narrative | scorecard)`: Presentation method
- `recommendation (none | light | definitive)`: Conclusion strength

**Example:**
```
+++Compare(criteria=all, format=table, recommendation=definitive)
Compare React, Vue, and Angular for building a complex enterprise web application.
```

### `+++Explain`
When this decorator is applied, the response provides a clear explanation of code or concepts with appropriate detail.

**Parameters:**
- `depth (high-level | detailed | comprehensive)`: Explanation thoroughness
- `focus (how | why | both)`: Explanation emphasis
- `examples (none | few | many)`: Illustrative examples amount

**Example:**
```
+++Explain(depth=comprehensive, focus=both, examples=many)
Explain React's useEffect hook and its common use cases.
```

### `+++LearningPath`
When this decorator is applied, the response creates structured learning progression for technical topics.

**Parameters:**
- `duration (short | medium | long)`: Learning timeline
- `depth (foundational | practical | comprehensive)`: Knowledge level goal
- `style (hands-on | academic | mixed)`: Learning approach

**Example:**
```
+++LearningPath(duration=medium, depth=practical, style=hands-on)
Create a learning plan for a backend developer who wants to learn Kubernetes.
```

### `+++ErrorDiagnosis`
When this decorator is applied, the response analyzes error patterns and provides systematic troubleshooting.

**Parameters:**
- `language (javascript | python | java | go | other)`: Programming language context
- `depth (symptom | cause | solution)`: Diagnostic thoroughness
- `format (checklist | decision-tree | step-by-step | narrative)`: Diagnostic structure

**Example:**
```
+++ErrorDiagnosis(language=python, depth=cause, format=decision-tree)
Debug this error: "TypeError: cannot use a string pattern on a bytes-like object" in our file processing code.
```

### `+++CodeContext`
When this decorator is applied, the response provides relevant contextual information for code understanding.

**Parameters:**
- `levels (implementation | function | module | system | business)`: Contextual scope
- `focus (dependencies | flow | purpose | evolution | all)`: Context emphasis
- `presentation (brief | standard | comprehensive)`: Detail level

**Example:**
```
+++CodeContext(levels=all, focus=flow, presentation=comprehensive)
Explain how this authentication middleware fits into our Express.js application architecture.
```

### `+++TechDebtControl`
When this decorator is applied, the response guides how technical debt should be handled during implementation.

**Parameters:**
- `accept (none | minimal | moderate | pragmatic)`: Level of acceptable technical debt
- `document (none | comments | todos | issues | comprehensive)`: How tech debt should be documented
- `tradeoff (nothing | completeness | performance | elegance)`: What can be traded for quality

**Example:**
```
+++TechDebtControl(accept=pragmatic, document=todos, tradeoff=elegance)
Implement a quick solution for the file upload feature we need for the demo next week.
```

### `+++ComplexityLevel`
When this decorator is applied, the response specifies the permitted complexity level for the implementation.

**Parameters:**
- `code (simple | moderate | complex | necessary-only)`: Code complexity limit
- `concepts (beginner-friendly | intermediate | advanced)`: Conceptual complexity limit
- `dependencies (none | minimal | standard | whatever-needed)`: External dependency usage

**Example:**
```
+++ComplexityLevel(code=simple, concepts=beginner-friendly, dependencies=minimal)
Implement a simple date formatter utility that converts between different date formats without external libraries.
```

### `+++AsyncPattern`
When this decorator is applied, the response handles asynchronous operations with appropriate patterns for the language and environment.

**Parameters:**
- `approach (promises | async-await | observables | callbacks | streams | events)`: Asynchronous programming model to use
- `error-handling (try-catch | error-first-callbacks | promise-rejection | error-streams)`: Error handling strategy
- `cancellation (none | manual | timeout | signal)`: Support for operation cancellation

**Example:**
```
+++AsyncPattern(approach=async-await, error-handling=try-catch, cancellation=signal)
Create a function that fetches user data from multiple APIs in parallel and combines the results.
```

### `+++CodeGen`
When this decorator is applied, the response generates code snippets or complete solutions with configurable style and documentation level.

**Parameters:**
- `language (python | javascript | typescript | java | csharp | go | rust)`: Programming language to generate code in
- `style (functional | oop | procedural | reactive | declarative)`: Programming paradigm or coding style to use
- `comments (minimal | moderate | extensive)`: Level of code documentation to include
- `error_handling (none | basic | comprehensive)`: Level of error handling to include

**Example:**
```
+++CodeGen(language=typescript, style=functional, comments=moderate, error_handling=basic)
Create a utility function that calculates the total price of items in a shopping cart with discounts applied.
```

### `+++Interface`
When this decorator is applied, the response generates interface definitions for APIs, libraries, or components.

**Parameters:**
- `style (rest | graphql | rpc | soap | class | function | event-driven)`: Interface paradigm or API style
- `verbosity (minimal | documented | extensive)`: Level of documentation detail
- `format (code | openapi | schema | typescript)`: Output format of the interface

**Example:**
```
+++Interface(style=rest, verbosity=extensive, format=openapi)
Create an API interface for a user management service with authentication, user profiles, and role management.
```

### `+++CodeStandards`
When this decorator is applied, the response applies coding standards and best practices.

**Parameters:**
- `standard (company | language-specific | custom | industry)`: Code standard type
- `strictness (recommended | required | strict)`: Enforcement level
- `focus (formatting | naming | patterns | security | all)`: Areas of emphasis

**Example:**
```
+++CodeStandards(standard=language-specific, strictness=required, focus=all)
Apply JavaScript best practices to this React component following Airbnb style guide.
```

### `+++CommitMessage`
When this decorator is applied, the response generates structured, informative commit messages.

**Parameters:**
- `style (conventional | detailed | minimal | semantic | custom)`: Commit message format
- `scope (include | exclude)`: Change scope information
- `issue (none | reference | close)`: Include issue references

**Example:**
```
+++CommitMessage(style=conventional, scope=include, issue=reference)
Generate a commit message for changes that improve error handling in the authentication module, related to issue #143.
```

### `+++MockData`
When this decorator is applied, the response generates test fixtures and mock data for testing.

**Parameters:**
- `complexity (simple | moderate | complex)`: Sophistication of generated data
- `format (json | csv | sql | code | graphql)`: Output format of the mock data
- `size (small | medium | large)`: Amount of mock data to generate

**Example:**
```
+++MockData(complexity=complex, format=json, size=medium)
Generate mock data for an e-commerce system with users, products, orders, and reviews.
```

### `+++Backup`
When this decorator is applied, the response designs backup and recovery strategies.

**Parameters:**
- `criticality (low | medium | high | mission-critical)`: Data importance level
- `rpo (minutes | hours | days | custom)`: Recovery Point Objective
- `rto (minutes | hours | days | custom)`: Recovery Time Objective

**Example:**
```
+++Backup(criticality=mission-critical, rpo=minutes, rto=minutes)
Design a backup and disaster recovery strategy for our financial transaction database.
```

### `+++Scalability`
When this decorator is applied, the response designs system architecture with focus on specific scaling dimensions.

**Parameters:**
- `dimension (users | data | transactions | geographic | complexity)`: Scaling aspect to focus on
- `target (10x | 100x | 1000x | all)`: Scale magnitude to design for
- `approach (horizontal | vertical | hybrid | cloud-native)`: Scaling strategy to implement

**Example:**
```
+++Scalability(dimension=transactions, target=1000x, approach=horizontal)
Design a payment processing system that can handle Black Friday-level traffic spikes.
```

### `+++Optimize`
When this decorator is applied, the response optimizes code for specific metrics while respecting constraints.

**Parameters:**
- `for (speed | memory | readability | size | network)`: The primary optimization target
- `constraints (backwards-compatible | minimal-changes | no-external-dependencies | same-api | none)`: Limitations that must be respected
- `priority (max-gains | min-risk | balanced)`: Trade-off preference when optimizations conflict

**Example:**
```
+++Optimize(for=memory, constraints=backwards-compatible, priority=min-risk)
Optimize this image processing function that's consuming too much memory.
```

### `+++ChangeVerification`
When this decorator is applied, the response focuses on verifying that changes have the intended effect and don't introduce regressions.

**Parameters:**
- `type (functionality | visual | performance | security)`: Verification type
- `method (manual-testing | automated-tests | dom-inspection | logging)`: Verification method
- `coverage (changed-only | dependent-areas | comprehensive)`: Verification coverage

**Example:**
```
+++ChangeVerification(type=functionality, method=dom-inspection, coverage=dependent-areas)
Verify that the UI updates properly after implementing the sorting functionality. Check all elements that should respond to the sort action.
```

### `+++CodeAudit`
When this decorator is applied, the response requests an audit of existing code to identify issues before making changes.

**Parameters:**
- `scope (function | component | module | system | specific-issue)`: Audit scope
- `focus (bugs | performance | security | maintainability | all)`: Audit focus areas
- `output (summary | detailed | categorized | prioritized)`: Audit output format

**Example:**
```
+++CodeAudit(scope=module, focus=performance, output=detailed)
Refactor this payment processing code to improve performance.
```

### `+++Deployment`
When this decorator is applied, the response generates deployment approaches for applications and services.

**Parameters:**
- `platform (aws | azure | gcp | kubernetes | heroku | netlify | vercel | on-prem)`: Deployment target
- `strategy (blue-green | canary | rolling | recreate | custom)`: Deployment methodology
- `environment (dev | staging | production | multi-region)`: Target environment

**Example:**
```
+++Deployment(platform=kubernetes, strategy=blue-green, environment=production)
Create a deployment plan for our microservices architecture ensuring zero downtime.
```

### `+++Estimation`
When this decorator is applied, the response helps with effort estimation for development tasks.

**Parameters:**
- `method (t-shirt | fibonacci | hours | days)`: Estimation approach
- `confidence (best-case | worst-case | expected | range)`: Estimate type
- `factors (complexity | risk | unknowns | dependencies | all)`: Considerations to include

**Example:**
```
+++Estimation(method=fibonacci, confidence=range, factors=all)
Estimate the effort required to implement a new authentication system with social login and MFA support.
```

### `+++ExtendCode`
When this decorator is applied, the response requests extending or enhancing existing code with new functionality without complete rewrites.

**Parameters:**
- `approach (add-function | add-method | add-feature | enhance-existing)`: How to extend the code
- `impact (none | minimal | moderate | significant)`: Level of changes to existing code
- `maintain (api | architecture | naming | performance | all)`: Aspects to maintain

**Example:**
```
+++ExtendCode(approach=add-method, impact=minimal, maintain=all)
Add a method to this user service class that allows retrieving users by email domain.
```

### `+++IncrementalBuild`
When this decorator is applied, the response indicates that the code should be built incrementally, with focus on one feature/component at a time.

**Parameters:**
- `focus (feature | component | function | integration | refactoring)`: Current implementation focus
- `dependencies (mock | stub | implement | import-existing)`: How to handle dependencies
- `completion (minimal-viable | functional | robust | production-ready)`: Expected completion of this increment

**Example:**
```
+++IncrementalBuild(focus=component, dependencies=mock, completion=minimal-viable)
Implement the user profile card component that displays basic user information and an avatar.
```

### `+++ImplPhase`
When this decorator is applied, the response indicates which phase of implementation the AI should focus on, controlling scope and detail level.

**Parameters:**
- `stage (design | scaffold | core | refinement | optimization | documentation)`: Current implementation phase
- `scope (function | component | module | service | system)`: Implementation scope boundary
- `iteration (number)`: Implementation iteration number

**Example:**
```
+++ImplPhase(stage=scaffold, scope=component, iteration=1)
Create the initial structure for a user authentication component with login/register forms.
```

### `+++Iterate`
When this decorator is applied, the response indicates this is an iteration on previously generated code, with specific improvements needed.

**Parameters:**
- `version (number)`: Iteration number
- `feedback (review-comments | bug-fixes | performance-issues | feature-requests)`: Type of feedback addressed
- `priority (correctness | completeness | performance | readability)`: Implementation priority

**Example:**
```
+++Iterate(version=2, feedback=review-comments, priority=correctness)
Update the authentication middleware based on these code review comments: 1) Token expiration is not properly checked, 2) Error messages are not consistent.
```

### `+++MemoryConstraint`
When this decorator is applied, the response helps manage implementation within AI context window limitations by focusing on specific code portions.

**Parameters:**
- `focus (single-function | component | interface | specific-feature)`: Part of the code to focus on
- `implementation (skeleton | core-logic | full-implementation | with-tests)`: Implementation completeness
- `context (ignore | summarize | interface-only | stub)`: How to handle surrounding code

**Example:**
```
+++MemoryConstraint(focus=single-function, implementation=full-implementation, context=interface-only)
Implement the user authentication function that verifies credentials against our database.
```

### `+++SystemIntegration`
When this decorator is applied, the response provides guidance for integrating with existing systems and services.

**Parameters:**
- `systems (string)`: External systems to integrate with
- `approach (adapter | direct | facade | proxy | bridge)`: Integration approach
- `coupling (loose | moderate | tight)`: Desired coupling level

**Example:**
```
+++SystemIntegration(systems=payment-gateway,inventory-service, approach=facade, coupling=loose)
Implement an order processing service that integrates with our payment gateway and inventory system.
```

### `+++Infrastructure`
When this decorator is applied, the response generates infrastructure as code templates for environment provisioning.

**Parameters:**
- `tool (terraform | cloudformation | arm | pulumi | cdk | ansible)`: Infrastructure as code tool
- `environment (dev | staging | prod | multi-environment)`: Target environment
- `approach (immutable | mutable | hybrid)`: Infrastructure philosophy

**Example:**
```
+++Infrastructure(tool=terraform, environment=multi-environment, approach=immutable)
Create infrastructure as code for a web application with frontend, API, and database tiers.
```

### `+++LoggingStrategy`
When this decorator is applied, the response defines a strategy for implementing logging to aid debugging and monitoring.

**Parameters:**
- `level (minimal | standard | verbose | diagnostic)`: Logging detail level
- `targets (console | file | service | all)`: Logging targets
- `lifecycle (temporary | permanent | conditional | togglable)`: Log lifecycle management

**Example:**
```
+++LoggingStrategy(level=diagnostic, targets=console, lifecycle=togglable)
Implement comprehensive logging for the authentication flow that can be enabled/disabled with a debug flag.
```

### `+++Migration`
When this decorator is applied, the response plans migration approaches between system states.

**Parameters:**
- `from (string)`: Current state
- `to (string)`: Target state
- `approach (big-bang | incremental | strangler-fig | parallel-run)`: Migration strategy

**Example:**
```
+++Migration(from=monolith, to=microservices, approach=strangler-fig)
Create a migration plan for transitioning our monolithic e-commerce application to microservices.
```

### `+++PostMortem`
When this decorator is applied, the response creates incident reviews and postmortem documents.

**Parameters:**
- `format (timeline | 5-whys | fishbone | comprehensive)`: Document structure
- `focus (what-happened | why | prevention | balanced)`: Analysis emphasis
- `audience (team | leadership | stakeholders | public)`: Target readers

**Example:**
```
+++PostMortem(format=comprehensive, focus=balanced, audience=team)
Create a postmortem for the database outage we experienced yesterday that caused 45 minutes of downtime.
```

### `+++ReleaseNotes`
When this decorator is applied, the response creates structured release notes for product updates.

**Parameters:**
- `audience (users | developers | stakeholders | public)`: Target reader
- `detail (high-level | detailed)`: Information depth
- `format (changelog | narrative | categorized | markdown | html)`: Release note structure

**Example:**
```
+++ReleaseNotes(audience=users, detail=detailed, format=markdown)
Create release notes for version 2.3.0 which includes new payment methods, performance improvements, and bug fixes.
```

### `+++Reproduce`
When this decorator is applied, the response creates detailed steps to reproduce a reported issue.

**Parameters:**
- `environment (local | staging | prod | docker | specific-version)`: Target environment for reproduction
- `detail (minimal | comprehensive | debug-oriented)`: Level of detail in steps
- `format (steps | script | docker-compose | video-script)`: Output format

**Example:**
```
+++Reproduce(environment=docker, detail=comprehensive, format=script)
Create reproduction steps for a race condition we're seeing in our payment processing service.
```

### `+++Roadmap`
When this decorator is applied, the response plans development timelines and feature sequencing.

**Parameters:**
- `timeframe (sprint | quarter | halfyear | year)`: Planning horizon
- `focus (features | technical-debt | security | performance | balanced)`: Roadmap emphasis
- `detail (high-level | milestones | detailed)`: Depth of planning

**Example:**
```
+++Roadmap(timeframe=quarter, focus=features, detail=milestones)
Create a product roadmap for our e-commerce platform focusing on enhancing the checkout experience.
```

### `+++SRE`
When this decorator is applied, the response applies Site Reliability Engineering practices.

**Parameters:**
- `focus (slos | error-budgets | runbooks | postmortems | chaos-eng | automation)`: SRE practice area
- `maturity (beginner | intermediate | advanced)`: Organization SRE maturity
- `output (implementation | roadmap | assessment)`: Deliverable type

**Example:**
```
+++SRE(focus=slos, maturity=intermediate, output=implementation)
Develop SLOs and error budgets for our e-commerce platform focusing on checkout and payment processing.
```

### `+++StepByStepImpl`
When this decorator is applied, the response requests a step-by-step implementation approach, with explicitly labeled stages.

**Parameters:**
- `detail (minimal | moderate | comprehensive)`: Level of explanation and comments
- `steps (string)`: Number of implementation steps
- `output (code-only | code-with-explanation | explanation-then-code)`: What to include in each step

**Example:**
```
+++StepByStepImpl(detail=comprehensive, steps=5, output=explanation-then-code)
Implement a JWT authentication middleware for Express.js that verifies tokens and extracts user roles.
```

### `+++TechStack`
When this decorator is applied, the response recommends technology combinations based on requirements.

**Parameters:**
- `for (web | mobile | desktop | iot | data | ai | enterprise)`: Target application type
- `constraints (budget | scale | team-size | performance | security | timeline)`: Project limitations
- `maturity (bleeding-edge | modern-stable | established | enterprise-proven)`: Technology maturity preference

**Example:**
```
+++TechStack(for=web, constraints=budget, maturity=modern-stable)
Recommend a technology stack for a B2B SaaS application with emphasis on rapid development and scalability.
```

## Examples

<example>
+++Algorithm(type=graph, complexity=linear, approach=iterative)
Write an algorithm to find all connected components in an undirected graph.
</example>

<example>
+++CodeReview(depth=thorough, focus=security, tone=constructive)
+++BestPractices(domain=security, context=web, level=advanced)
Review this authentication middleware implementation for a Node.js application.
</example>

<example>
+++Refactor(goal=performance, level=moderate, preserve=both)
+++OptimizationFocus(goal=speed, constraints=backward-compatibility, level=micro)
Refactor this database query function that's causing performance issues in our Django application.
</example>

<example type="invalid">
+++Algorithm
Write a sorting algorithm.
(Missing required parameters and specificity)
</example>

<example type="invalid">
UseDesignPattern(pattern=singleton)
Create a singleton class for a database connection.
(Missing +++ prefix)
</example>