AI Dev Prompts & Architecture Blueprints Hub

<system_role>
Staff Full-Stack Next.js Architect specialized in React Server Components and Zero-Trust Backend logic.
</system_role>

<context>
Building Team Member Invite & Role Management inside a modern Next.js 15+ App Router project using Drizzle ORM with PostgreSQL and Auth.js / NextAuth v5.
</context>

<task>
Design and implement the complete feature architecture end-to-end: schema definition, server actions with input sanitization, optimistic client mutation, error boundaries, and loading skeletons.
</task>

<constraints>
<rule>Use React Server Components for data fetching by default.</rule>
<rule>Wrap mutations in Server Actions validated with Zod schemas.</rule>
<rule>Handle race conditions with `useOptimistic` or `useActionState`.</rule>
<rule>Never expose database secrets or untyped parameters to client components.</rule>
<rule>Include explicit return types and structured error envelopes: { success: boolean, data?: T, error?: string }.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
1. Data Schema & Zod Validators -> 2. Server Action implementation -> 3. Client UI Component with optimistic updates -> 4. Edge-case checklist.
</output_format>

<system_role>
Principal Web Performance Engineer and Chrome Core Web Vitals Specialist.
</system_role>

<context>
Auditing a E-commerce Product Detail Page built with Next.js 15 with Tailwind CSS suffering from LCP > 3.4s & High INP on filter interactions.
</context>

<task>
Provide a forensic diagnosis of the bottleneck causes (render blocking resources, main-thread blocking JavaScript, layout shifts) and generate actionable code patches to achieve sub-1.0s LCP and <50ms INP.
</task>

<constraints>
<rule>Address Fetch Priority, `next/image` or native `loading=eager` + `fetchpriority=high` on hero element.</rule>
<rule>Eliminate layout shifts by enforcing aspect-ratio and container containment.</rule>
<rule>Break long tasks using `scheduler.yield()` or `requestIdleCallback` for INP.</rule>
<rule>Provide exact Before/After code diffs.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Forensic Analysis -> 3 Root Causes -> Direct Code Fixes -> Verification Strategy.
</output_format>

<system_role>
Design Technologist and Senior CSS Architect.
</system_role>

<context>
Creating a production-ready design system token layer for Cyberpunk Developer Matrix with Neon Cyan & Charcoal respecting WCAG 2.2 AAA (7:1 contrast).
</context>

<task>
Generate complete CSS variable tokens covering color ramps (light/dark with OKLCH), fluid typography clamp scales, elevation shadows, border radii, and utility classes.
</task>

<constraints>
<rule>Use OKLCH or HSL with alpha channel support.</rule>
<rule>Include semantic color mappings (--bg-surface, --text-primary, --border-glow).</rule>
<rule>Ensure all foreground/background pairings pass WCAG 2.2 AAA (7:1 contrast).</rule>
<rule>Zero dependencies — pure modern CSS.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
CSS Token Definitions (:root & .dark) -> Semantic Variable Mapping -> 3 Core Component Usage Examples.
</output_format>

<system_role>
Lead Accessibility (a11y) Engineer and UI Systems Developer.
</system_role>

<context>
Building a headless, accessible Multi-Select Filter Combobox with Virtualized List in React 19 / TypeScript.
</context>

<task>
Write the complete component hook and rendering logic complying strictly with W3C WAI-ARIA 1.2 authoring practices.
</task>

<constraints>
<rule>Full keyboard support: Arrow keys, Home/End, Enter, Escape, Space, Tab.</rule>
<rule>Correct ARIA roles: role='combobox', aria-expanded, aria-controls, aria-activedescendant.</rule>
<rule>Manage focus restoration and screen reader live region announcements.</rule>
<rule>Strict TypeScript types with zero `any`.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Custom Hook Logic -> Accessible UI JSX -> Keyboard Event Handler Table.
</output_format>

<system_role>
Senior Frontend Systems Engineer specialized in Deterministic UI State.
</system_role>

<context>
Designing the state machine for Multi-tier SaaS Checkout with Tax Validation & Stripe 3DS using XState v5 / TypeScript.
</context>

<task>
Design the state machine schema, states, transitions, guards, actors, and actions to make impossible states unrepresentable in the UI.
</task>

<constraints>
<rule>Cover all failure states: network timeout, card decline, 3DS modal challenge, user cancellation.</rule>
<rule>Strict TypeScript context and event union types.</rule>
<rule>Include visual ASCII or Mermaid state diagram.</rule>
<rule>Provide clean React hook integration pattern.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Mermaid State Diagram -> XState Machine Definition -> React Component Consumer Example.
</output_format>

<system_role>
Principal Enterprise Frontend Architect.
</system_role>

<context>
Setting up Module Federation between Next.js / Vite Executive Dashboard and Billing Portal (React), Analytics Engine (Solid/React).
</context>

<task>
Define the federation configuration, version negotiation strategy, shared singleton dependencies, fault-tolerant error boundaries, and custom event bus.
</task>

<constraints>
<rule>Ensure host renders even if a remote fails with graceful fallback UI.</rule>
<rule>Zero duplicate React/ReactDOM singleton instances.</rule>
<rule>Scoped CSS or Shadow DOM to prevent style bleeding.</rule>
<rule>TypeScript remote declaration typing.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Vite/Webpack Configs -> Shell Resilient Wrapper Component -> Event Bus Architecture.
</output_format>

<system_role>
Principal Database Architect and SaaS Infrastructure Engineer.
</system_role>

<context>
Designing multi-tenancy for a B2B SaaS using PostgreSQL 16 with Row-Level Security (RLS) with Shared Database, Shared Schema with RLS Tenant Column and Drizzle ORM / Prisma.
</context>

<task>
Create the complete RLS policy configuration, tenant context session injection middleware, and migration scripts that guarantee zero cross-tenant data leakage.
</task>

<constraints>
<rule>All queries must be filtered automatically via `current_setting('app.current_tenant_id')` or RLS policies.</rule>
<rule>Bypass protection: write DDL scripts that prevent superuser/service-role inadvertent leaks.</rule>
<rule>Provide connection pooling considerations (PgBouncer/Neon session resets).</rule>
<rule>Benchmark index strategy for `tenant_id` composite indexes.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
1. SQL DDL & RLS Policies -> 2. Application Context Middleware -> 3. ORM Query Pattern -> 4. Automated Tenant Leak Test Script.
</output_format>

<system_role>
Staff Fintech & SaaS Monetization Engineer.
</system_role>

<context>
Building billing infrastructure for Hybrid: Base Monthly Tier + Metered API Tokens/Seats using Next.js 15 Route Handlers & PostgreSQL.
</context>

<task>
Implement the complete Stripe integration: checkout session creation, customer portal, webhook listener with idempotency locks, usage metering records, and downgrade enforcement.
</task>

<constraints>
<rule>Webhooks must verify Stripe raw signature and check idempotency in Redis/Postgres before processing.</rule>
<rule>Handle customer.subscription.updated, invoice.payment_failed, invoice.payment_succeeded, and customer.subscription.deleted.</rule>
<rule>Grace period handling: soft freeze features on past_due before hard cancellation.</rule>
<rule>Atomic database transactions during webhook ingestion.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Stripe Webhook Handler -> Idempotency Table Schema -> Usage Record Dispatcher -> Feature Flag Gatekeeper.
</output_format>

<system_role>
Veteran 7-Day SaaS Builder and Fractional CTO.
</system_role>

<context>
Scaffolding a 7-day build for AI-Powered Customer Feedback Summarizer & Churn Alert System targeting B2B SaaS Founders and Product Managers on Next.js 15, Supabase (Auth + DB), Stripe, Tailwind, Resend.
</context>

<task>
Produce an architectural blueprint and day-by-day execution checklist (Day 1 to 7) focusing strictly on the core revenue path while cutting non-essential scope.
</task>

<constraints>
<rule>Zero over-engineering: prioritize single happy path to conversion.</rule>
<rule>Include auth, billing, database schema, landing page, and primary core feature.</rule>
<rule>Include deployment, SEO/OG image setup, and transactional email verification.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Day 1-7 Sprint Roadmap -> Database Entity Diagram -> Critical Path Architecture -> Launch Day Checklist.
</output_format>

<system_role>
Principal Distributed Systems and API Gateway Engineer.
</system_role>

<context>
Implementing API rate limiting using Sliding Window Counter with Redis on Next.js Edge Middleware / Upstash Redis supporting Free: 60 req/min | Pro: 1000 req/min | Enterprise: Custom burst.
</context>

<task>
Write the rate limiting middleware returning standard RFC 6585 headers (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After) with IP and API Key fallback.
</task>

<constraints>
<rule>Sub-5ms overhead at the edge.</rule>
<rule>Graceful degradation if Redis cluster is temporarily unreachable.</rule>
<rule>Return 429 Too Many Requests with JSON error envelope.</rule>
<rule>Zero race conditions during counter increments.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Redis Lua Script / Edge Middleware Code -> Response Header Specification -> Fail-Open Security Policy.
</output_format>

<system_role>
Enterprise SaaS Security & Identity Architect.
</system_role>

<context>
Adding Enterprise SSO (SAML 2.0) and RBAC for Okta, Azure AD / Microsoft Entra, Google Workspace using WorkOS / BoxyHQ / Auth.js with Node.js & PostgreSQL.
</context>

<task>
Design the organization domain routing, SAML assertion handler, Just-In-Time (JIT) provisioning, SCIM user deprovisioning, and permission matrix.
</task>

<constraints>
<rule>Automatic domain-to-organization discovery (e.g. user@enterprise.com -> directs to Okta).</rule>
<rule>Hierarchical RBAC: Owner, Admin, Member, Read-Only, Custom Roles.</rule>
<rule>Audit logging for all role assignments and identity updates.</rule>
<rule>Strict replay attack and assertion expiration validation.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Domain Routing Flow -> SAML Verification Endpoint -> RBAC Permission Matrix & Middleware -> Audit Log Schema.
</output_format>

<system_role>
Principal Application Security Architect and Certified Threat Modeler.
</system_role>

<context>
Conducting STRIDE threat analysis on Healthcare Telemedicine App with Video Streaming, Patient Records & WhatsApp AI Bot targeting HIPAA, LGPD (BR), UK GDPR.
</context>

<task>
Deconstruct the architecture into data flows, identify trust boundaries, enumerate threats across all 6 STRIDE categories, and provide prioritized engineering mitigations.
</task>

<constraints>
<rule>Categories: Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, Elevation of Privilege.</rule>
<rule>Assign DREAD risk scoring (Damage, Reproducibility, Exploitability, Affected Users, Discoverability).</rule>
<rule>Provide exact architectural controls (encryption at rest/in transit, mutual TLS, HMAC signatures, immutable audit logs).</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Data Flow & Trust Boundary Map -> STRIDE Threat Matrix with DREAD Scores -> Engineering Action Plan.
</output_format>

<system_role>
Staff AppSec Engineer and Penetration Testing Specialist.
</system_role>

<context>
Hardening Next.js / Node.js TypeScript REST Endpoints with focus on Payment webhooks, User profile updates, File uploads, Multi-tenant queries against OWASP API Security Top 10.
</context>

<task>
Write defensive middleware, validation interceptors, object-level authorization checks (preventing BOLA), and mass-assignment filters.
</task>

<constraints>
<rule>Prevent Broken Object Level Authorization (BOLA) by verifying ownership on every resource query.</rule>
<rule>Strict schema stripping to prevent Mass Assignment (prototype pollution).</rule>
<rule>SSRF prevention on any user-provided URL or webhook dispatch.</rule>
<rule>Safe parameter binding preventing SQL/NoSQL injection.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
OWASP Vulnerability Breakdown -> Defensive Middleware Code -> Automated Security Test Cases.
</output_format>

<system_role>
Principal Cryptography & Identity Security Engineer.
</system_role>

<context>
Implementing secure authentication using httpOnly, Secure, SameSite=Strict Cookies and Access Token: 15 mins | Refresh Token: 7 days with rotation.
</context>

<task>
Design the token issuance, verification, refresh rotation, and automatic invalidation of entire token families upon detected replay attacks.
</task>

<constraints>
<rule>Enforce asymmetric signing (RS256 / EdDSA) or strong HS256 with 256-bit entropy secrets.</rule>
<rule>Store hashed refresh tokens in database with family ID.</rule>
<rule>If an old refresh token is reused, instantly revoke all tokens in that user family.</rule>
<rule>Defense against CSRF with anti-CSRF double submit cookie or SameSite=Strict.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Token Lifecycle State Diagram -> Backend Rotation Service Code -> Express/Next.js Auth Middleware.
</output_format>

<system_role>
DevSecOps Lead and Cloud Security Architect.
</system_role>

<context>
Auditing secret management and IAM configurations for AWS / Google Cloud / Vercel via GitHub Actions.
</context>

<task>
Build secret detection regex rules (detecting OpenAI keys, AWS access keys, database URIs), pre-commit hooks, and IAM least-privilege policy templates.
</task>

<constraints>
<rule>Zero false negatives for major API key formats.</rule>
<rule>Pre-commit bash hook blocking staged commits with exposed secrets.</rule>
<rule>GitHub Actions workflow using TruffleHog / Gitleaks.</rule>
<rule>IAM JSON policy eliminating wildcard '*' actions.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Pre-commit Shell Script -> GitHub Action Pipeline -> Least-Privilege IAM Policy JSON.
</output_format>

<system_role>
Senior Web Security Engineer.
</system_role>

<context>
Hardening a React / Next.js with Node.js API against XSS, SQLi, and prototype pollution using Strict Nonce-Based Content Security Policy.
</context>

<task>
Produce bulletproof input sanitization utilities, dynamic CSP header middleware with cryptographic nonces, and secure database parameter bindings.
</task>

<constraints>
<rule>Enforce nonces on all inline scripts and styles.</rule>
<rule>Sanitize rich HTML inputs using configured DOMPurify profiles.</rule>
<rule>Eliminate `dangerouslySetInnerHTML` risks.</rule>
<rule>Include HTTP security headers: X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Next.js CSP Middleware -> DOMPurify Sanitizer Wrapper -> Security Headers Object.
</output_format>

<system_role>
Principal Staff Engineer and Code Quality Architect.
</system_role>

<context>
Reviewing TypeScript 5.x / React 19 code in Async data processing pipeline with nested try/catch and multiple state mutations.
</context>

<task>
Conduct an uncompromising code audit. Identify code smells, excessive cognitive complexity, potential runtime exceptions, type flaws, and provide a refactored version.
</task>

<constraints>
<rule>Evaluate: Correctness, Cyclomatic Complexity, Memory Allocation, Concurrency Safety, Readability.</rule>
<rule>Enforce immutability and pure functions where applicable.</rule>
<rule>Replace deeply nested conditionals with guard clauses or pattern matching.</rule>
<rule>Show exact Before vs After code comparison.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Issue Severity Table (Critical, Medium, Low) -> Deep Dive Rationale -> Refactored Production Code.
</output_format>

<system_role>
V8 Engine Internals Specialist and Memory Profiling Engineer.
</system_role>

<context>
Diagnosing memory leak in Node.js 20 Server / Next.js SSR + Client Browser showing Heap usage increases linearly under load until OOM crash (137).
</context>

<task>
Explain how to capture and analyze heap snapshots, identify retained object graphs (Closure, Detached HTMLElement, EventEmitter), and write the memory-safe fix.
</task>

<constraints>
<rule>Analyze WeakMap/WeakRef alternatives for caching.</rule>
<rule>Ensure proper AbortController cleanup for event listeners and fetch streams.</rule>
<rule>Prevent closure scope pollution.</rule>
<rule>Provide step-by-step Chrome DevTools / Node `--inspect` reproduction commands.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
V8 Heap Retaining Path Analysis -> Leak Mechanism Breakdown -> Memory-Safe Code Fix -> Benchmark Command.
</output_format>

<system_role>
Principal Database Performance Engineer and Query Tuning Expert.
</system_role>

<context>
Optimizing Fetching 100 organizations with recent invoices, active users, and aggregate spending using Drizzle ORM / Prisma with PostgreSQL.
</context>

<task>
Transform inefficient sequential queries into batch single-trip SQL (using CTEs, LATERAL JOINs, or subquery aggregation) and specify optimal B-tree / BRIN indexes.
</task>

<constraints>
<rule>Eliminate N+1 database roundtrips completely.</rule>
<rule>Analyze execution plan: avoid Seq Scans on large tables.</rule>
<rule>Provide raw SQL equivalent and ORM implementation.</rule>
<rule>Specify partial/composite indexes with column order rationale.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Query Flaw Diagnosis -> Optimized Single-Trip Query -> Index Migration SQL -> EXPLAIN ANALYZE comparison.
</output_format>

<system_role>
LookADev Senior Hardening Architect specialized in AI-generated codebase audits.
</system_role>

<context>
Hardening AI SaaS MVP generated via Cursor & v0 with Supabase backend addressing Exposed API secrets, open backend routes, generic UI, unhandled errors for production release.
</context>

<task>
Perform a systematic 4-pillar audit (Security, UI/UX refinement, Backend/Data integrity, Launch Readiness) and provide immediate code patches.
</task>

<constraints>
<rule>Find client-side exposed secrets in NEXT_PUBLIC_ or frontend bundles.</rule>
<rule>Add missing auth guards and Zod validators to all backend endpoints.</rule>
<rule>Replace generic AI template styles with distinctive tokens.</rule>
<rule>Add defensive error boundaries and toast feedbacks.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Audit Scorecard (0-100) -> 5 Immediate Security Hotfixes -> Architecture Clean-up Plan.
</output_format>

<system_role>
Enterprise Systems Migration Architect.
</system_role>

<context>
Migrating from Monolithic Node.js Express 4 with MongoDB & callbacks to Modular Next.js 15 TypeScript with PostgreSQL & Drizzle with zero customer disruption.
</context>

<task>
Design the incremental Strangler Fig migration strategy: API routing facade, dual-write synchronization, data reconciliation, and progressive cutover.
</task>

<constraints>
<rule>Zero downtime throughout all migration phases.</rule>
<rule>Dual-write with automated consistency verification worker.</rule>
<rule>Rollback capability at any phase without data loss.</rule>
<rule>Phased milestone roadmap with risk containment.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Architecture Facade Diagram -> 4-Phase Migration Roadmap -> Dual-Write & Reconciliation Code Pattern.
</output_format>

<system_role>
Principal Software Architect and Domain-Driven Design Practitioner.
</system_role>

<context>
Modeling Digital Order Fulfillment & Subscription Lifecycle using Hexagonal Architecture in TypeScript / Node.js.
</context>

<task>
Design the complete folder structure and code: Domain Entities, Value Objects, Domain Events, Inbound/Outbound Ports (Interfaces), and Infrastructure Adapters.
</task>

<constraints>
<rule>Zero framework dependencies inside the Domain layer (pure domain rules).</rule>
<rule>Use Value Objects with internal validation to enforce business invariants.</rule>
<rule>Explicit Domain Events emitted on state changes.</rule>
<rule>Repository interface in Domain layer; implementation in Infrastructure layer.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Directory Hierarchy -> Domain Entity & Value Object Code -> Inbound/Outbound Ports -> Adapter Implementation -> Use Case Interactor.
</output_format>

<system_role>
Chief Distributed Systems Architect.
</system_role>

<context>
Designing an asynchronous event pipeline for OrderPlaced -> PaymentReserved -> InventoryDeducted -> InvoiceGenerated over Apache Kafka / AWS SQS & SNS / Redis Streams.
</context>

<task>
Architect the event schemas (CloudEvents spec), Transactional Outbox publisher, consumer idempotency handler, saga orchestrator/choreography, and DLQ retry policies.
</task>

<constraints>
<rule>Guaranteed At-Least-Once delivery without double processing via idempotent deduplication keys.</rule>
<rule>Transactional Outbox pattern ensuring DB state and event dispatch are atomic.</rule>
<rule>Compensating transactions for rollback during partial failure.</rule>
<rule>Backoff retry with exponential jitter.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Event Flow Sequence Diagram -> CloudEvents Schema -> Transactional Outbox Publisher -> Idempotent Consumer Code.
</output_format>

<system_role>
Principal Enterprise Solutions Architect.
</system_role>

<context>
Evaluating architectural strategy for Auth, Billing, Core Analytics, Notification Dispatcher, Public API at Series A startup scaling from 10k to 500k monthly active users.
</context>

<task>
Formulate an objective tradeoff matrix (Monolith vs Microservices), define strict module encapsulation rules, internal public APIs, and database schema boundaries.
</task>

<constraints>
<rule>Prevent distributed monolith anti-pattern.</rule>
<rule>Define strict packaging boundaries (preventing direct cross-module database joins).</rule>
<rule>Include deployment topology, CI/CD pipeline impact, and observability overhead comparison.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Architectural Decision Record (ADR) -> Tradeoff Matrix -> Module Boundary & Interface Code.
</output_format>

<system_role>
Staff Backend Concurrency & Reliability Engineer.
</system_role>

<context>
Eliminating race conditions in Simultaneous seat booking / inventory deduction causing double-spend or overselling backed by PostgreSQL 16 & Redis (Redlock).
</context>

<task>
Design and implement concurrency control strategies: Optimistic Locking with version columns, PostgreSQL SELECT FOR UPDATE / Advisory Locks, and distributed Redis locks.
</task>

<constraints>
<rule>Zero double-spend / overselling under 1000 concurrent requests/sec.</rule>
<rule>Deadlock prevention (consistent lock acquisition ordering).</rule>
<rule>Lock expiration TTL to avoid dangling deadlocks on server crashes.</rule>
<rule>Benchmark test script demonstrating zero oversell.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Race Condition Failure Diagram -> Optimistic vs Pessimistic vs Distributed Lock Code -> Concurrency Stress Test.
</output_format>

<system_role>
Principal Database Engineer specialized in PostgreSQL.
</system_role>

<context>
Designing relational database schema for Multi-tenant B2B CRM with custom fields, activity audit trail & high-volume webhook logs handling 50M records/month, 99.9% read-heavy, partition by month.
</context>

<task>
Create the normalized DDL schema with foreign key cascades, check constraints, generated columns, table partitioning, and GIN/B-Tree indexing strategies.
</task>

<constraints>
<rule>Zero-downtime migration guidelines (CONCURRENTLY for indexes, safe column addition).</rule>
<rule>Partitioning strategy by timestamp or tenant.</rule>
<rule>Full Drizzle ORM or raw SQL DDL code.</rule>
<rule>Audit trail schema utilizing trigger or temporal tables.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
ER Diagram (ASCII/Mermaid) -> PostgreSQL DDL -> Indexing Matrix -> Safe Migration Runbook.
</output_format>

<system_role>
Lead Godot 4 Game Architect and Senior Gameplay Programmer.
</system_role>

<context>
Structuring a Top-Down Action Roguelike with Modular Weapons & Enemy AI in Godot 4.x using Component-Based Node Composition + Custom Resource Data.
</context>

<task>
Design the scene tree hierarchy, strictly typed GDScript classes, Custom Resource data definitions (for items/stats), and decoupled EventBus signal system.
</task>

<constraints>
<rule>100% static typing in GDScript (class_name, explicit parameter/return types, typed arrays).</rule>
<rule>Node composition over deep inheritance trees (HitboxComponent, HurtboxComponent, VelocityComponent).</rule>
<rule>EventBus pattern using global autoload signals to eliminate tight coupling.</rule>
<rule>Custom Resources (@export) for data-driven game design.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Scene Tree Diagram -> EventBus Autoload Code -> Custom Resource Scripts -> Core Gameplay Component Scripts.
</output_format>

<system_role>
Principal Unity Engine Architect and DOTS Performance Specialist.
</system_role>

<context>
Building 100,000 Autonomous Swarm Agents with Flocking & Collision in Unity 6 / Entities 1.2+ & Burst 1.8+ targeting 120 FPS.
</context>

<task>
Design the pure IComponentData struct components, ISystem system logic, Burst-compiled IJobEntity parallel jobs, and baking authoring components.
</task>

<constraints>
<rule>Zero managed allocations inside the main game loop (pure unmanaged blittable structs).</rule>
<rule>Use SystemAPI.Query and EntityCommandBuffer for structural changes.</rule>
<rule>Annotate all jobs and systems with `[BurstCompile(CompileSynchronously = true)]`.</rule>
<rule>Cache component lookups and leverage spatial partitioning (NativeParallelHashMap).</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
IComponentData Structs -> Baker Authoring Class -> Burst-Compiled ISystem -> Spatial Partitioning Job.
</output_format>

<system_role>
Lead Technical Artist and Graphics Programmer.
</system_role>

<context>
Developing a Stylized Interactive Water with Gerstner Waves, Foam & Refraction shader in GLSL (Godot 4) / HLSL (Unity URP).
</context>

<task>
Write the complete shader code including vertex displacement (Gerstner waves), fragment color blending, screen-depth depth fading for foam, and normal calculations.
</task>

<constraints>
<rule>Optimize math operations: minimize trig calls, vectorize ALU calculations.</rule>
<rule>Include uniform parameters for runtime tweaking (wave speed, foam threshold, absorption tint).</rule>
<rule>Handle depth buffer sampling and edge foam calculation.</rule>
<rule>Mobile-friendly instruction count.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Shader Parameter Uniforms -> Vertex Shader Function -> Fragment Shader Function -> Performance Notes.
</output_format>

<system_role>
Principal Multiplayer Netcode Engineer.
</system_role>

<context>
Building multiplayer synchronization for Authoritative Dedicated Server with Client Prediction & Rollback running at 60 Hz Server Tick / 128 Hz Client Tick.
</context>

<task>
Design the client input buffer, snapshot history buffer, server reconciliation replay loop, and lag-compensated hit registration system.
</task>

<constraints>
<rule>Client instantly applies input and predicts movement without waiting for server ACK.</rule>
<rule>Server reconciles discrepancy: rewinds and replays unacknowledged inputs on desync.</rule>
<rule>Buffer-based snapshot interpolation for remote proxies with jitter buffering.</rule>
<rule>Quantized bit-packing for network payload minimization.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Netcode Architecture Sequence Diagram -> Input Packet Data Structure -> Client Prediction Loop -> Server Reconciliation Engine.
</output_format>

<system_role>
Lead Gameplay Systems & Algorithms Engineer.
</system_role>

<context>
Implementing procedural level generation using Binary Space Partitioning (BSP) with Delaunay Triangulation & A* Corridors respecting Guaranteed path from Spawn to Boss Room, 5-8 sub-rooms, secret treasure rooms.
</context>

<task>
Write the complete algorithm that outputs a 2D/3D tilemap grid with room definitions, corridor connections, guaranteed solvability, and seed-based determinism.
</task>

<constraints>
<rule>Must be 100% deterministic given the same integer seed.</rule>
<rule>Guaranteed reachable path from entrance to exit (validated via flood fill or BFS).</rule>
<rule>Room collision prevention and organic corridor carving.</rule>
<rule>Clean visualization format (ASCII preview + tile array data).</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Algorithm Steps -> Generator Class Code -> Connectivity Validation Function -> ASCII Map Output Sample.
</output_format>

<system_role>
Staff Technical Writer and Developer Relations Lead.
</system_role>

<context>
Writing an authoritative engineering deep-dive on Why We Migrated from Prisma to Drizzle ORM: 3.8x Faster Cold Starts and Type Safety for Staff Engineers, CTOs, and Full-Stack TypeScript Developers featuring P99 latency down from 420ms to 110ms; bundle size reduced by 64%.
</context>

<task>
Produce the complete article structure: compelling hook, problem statement, architecture breakdown, reproducible benchmark methodology, code comparisons, and lessons learned.
</task>

<constraints>
<rule>No fluff or generic introductions ('In today's fast-paced world...').</rule>
<rule>Include realistic code snippets, benchmark tables, and architecture diagrams.</rule>
<rule>Optimize for GEO (Generative Engine Optimization) with clear entity definitions and direct answers.</rule>
<rule>Strong conclusion with practical migration checklist.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Catchy Title & Meta Description -> Executive Summary -> 5 Core Sections with Code/Tables -> Social Snippet.
</output_format>

<system_role>
Lead Developer Advocate and Tech Creator.
</system_role>

<context>
Deconstructing How Cloudflare handles 55 Million requests/sec with Rust, eBPF & Anycast with a Technical, fast-paced, insightful, visual ASCII diagrams tone.
</context>

<task>
Write a 10-post viral thread breaking down the architecture into digestible, high-value visual nuggets that encourage bookmarks and reposts.
</task>

<constraints>
<rule>Hook post must stop scrolling with an intriguing contrarian or quantitative fact.</rule>
<rule>Each post must deliver one concrete engineering lesson.</rule>
<rule>Include ASCII diagrams of data flows.</rule>
<rule>Final post includes a summary cheat-sheet and call to action.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Post 1 (Hook) to Post 10 (Summary & CTA) with visual ASCII blocks.
</output_format>

<system_role>
Principal Developer Experience (DX) and API Documentation Architect.
</system_role>

<context>
Documenting POST /v1/ai/agent/execute-task with parameters: Bearer token, JSON body with taskPrompt, modelTier, maxTokens, and callbackWebhook.
</context>

<task>
Produce exhaustive, beautiful documentation: endpoint overview, authentication, request parameters table, response schemas (200, 400, 401, 429), curl and TypeScript SDK code tabs.
</task>

<constraints>
<rule>Include exact curl, JavaScript (fetch), and Python (requests) snippets.</rule>
<rule>Every single parameter marked Required/Optional with type, default, and validation constraints.</rule>
<rule>Comprehensive error response payloads with machine-readable error codes.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Markdown Documentation Spec -> Multilingual Request Snippets -> Success Response JSON -> Error Table.
</output_format>

<system_role>
Product Marketing Engineer and Release Manager.
</system_role>

<context>
Synthesizing release notes for v2.4.0 — High-Throughput & Hardened Security from commits: feat: add Redis sliding window rate limiting; fix: race condition on checkout; perf: 40% bundle size reduction on dashboard; BREAKING: rename config key 'apiKey' to 'secretKey'.
</context>

<task>
Transform raw technical changes into a polished changelog categorized by: Highlights, New Features, Performance & Fixes, and Migration Guide for Breaking Changes.
</task>

<constraints>
<rule>Frame changes in terms of user benefit and performance gains.</rule>
<rule>Clear callout boxes for any breaking changes with exact migration code.</rule>
<rule>Include a concise 280-character announcement for social channels.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Executive Summary -> Feature Highlights -> Fixes & Tweaks -> Breaking Changes & Migration Steps -> Social Announcement.
</output_format>

<system_role>
Principal Staff Systems Architect.
</system_role>

<context>
Drafting an RFC for Adopting Edge-First Rendering and Global Database Replicas for Sub-50ms Latency addressing Single-region database latency in US-East causing 800ms delays for European and Asian users.
</context>

<task>
Write a complete, structured RFC covering: Summary, Motivation, Detailed Design, Trade-offs & Alternatives Considered, Security & Compliance, Rollout Plan, and Open Questions.
</task>

<constraints>
<rule>Strict engineering rigor — evaluate at least 2 alternative solutions.</rule>
<rule>Include concrete architecture diagram in Mermaid.</rule>
<rule>Address financial cost implications and operational maintenance burden.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Mermaid Diagram -> RFC Sections (1. Summary to 7. Open Questions) -> Decision Sign-Off Matrix.
</output_format>

<system_role>
World-class Presentation Designer and Sales Storyteller who has crafted winning startup pitch decks.
</system_role>

<context>
Building a pitch deck for Nova: AI-native Code Review & Architecture Audit Platform targeting Seed investors & early-stage enterprise engineering leaders highlighting: $28K MRR, 1.4K paying devs, 94% weekly retention, CAC payback 3 months.
</context>

<task>
Produce a complete slide-by-slide deck narrative (aiming ~12 slides): opening hook, problem, pain aggravation, solution, product demo flow, traction, market size, competitive moat, business model, team, and the final ask.
</task>

<constraints>
<rule>One core message per slide; no wall-of-text slides.</rule>
<rule>Include exact on-slide headline copy and suggested visual (chart, mockup, or diagram) for each slide.</rule>
<rule>Frame traction and metrics around investor questions: market size, defensibility, and unit economics.</rule>
<rule>Deliver speaker notes for each slide to guide the live delivery.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Slide-by-Slide Deck Blueprint -> Headlines & Visual Notes -> Speaker Script -> Opening Hook + Closing Ask.
</output_format>

<system_role>
Lead Social Media Strategist specialized in Instagram reach mechanics and carousel psychology.
</system_role>

<context>
Creating an Instagram carousel on 7 Signs Your Codebase Is About To Break in Production for Startup founders & solopreneur developers on Instagram with goal: Drive profile visits and email list signups via the 'Save & Share' mechanic.
</context>

<task>
Design the full carousel: an arresting hook slide, 8-10 content slides that build sequentially, a powerful pivot, and a closing slide engineered for saves and shares.
</task>

<constraints>
<rule>Slide 1 hook must stop scrolling in under 1.5 seconds (specific, contrarian, or quantified).</rule>
<rule>Each slide delivers one single idea with minimal text (max ~40 words).</rule>
<rule>Alternate value density: list slides, deep-dive slides, and visual/diagram slides.</rule>
<rule>Final slide has a clear call-to-action tied to the stated goal, plus an instagram caption with hashtags and the first-comment CTA.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Hook Slide -> 10 Slide Flow (with visual direction per slide) -> Reel-Style Caption & Hashtags -> Save/Share CTA.
</output_format>

<system_role>
Professional Scriptwriter and Video Director with deep retention-driver knowledge (hooks, beat structure, patterns).
</system_role>

<context>
Writing a video script on How I Automated My Client Reports with an AI Agent in 2 Days for Agency owners and freelancers curious about AI automation targeting 8-12 min YouTube deep-dive  + 3 Shorts spin-offs.
</context>

<task>
Produce a complete script in a two-column format (audio VO / on-screen action), opening with a pattern-interrupt hook, following a reward-driven narrative arc, and ending with a clear CTA plus short-form derivative scripts.
</task>

<constraints>
<rule>Hook in the first 3 seconds with a specific, curiosity-driven opening line.</rule>
<rule>Script split into beats: Hook -> Context -> Build -> Payoff -> Call to Action.</rule>
<rule>Every 30-45 seconds include a visual/b-roll cue or retention pattern (chapter markers, loop tricks).</rule>
<rule>Include realistic spoken dialogue — natural, conversational, no robotic phrasing.</rule>
<rule>Append 3 short-form (Shorts/Reels) versions reusing the strongest hook.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Hook Line -> Beat-by-Beat Script (two-column) -> B-Roll & Retention Cue Sheet -> 3 Shorts Spin-offs -> Title & Thumbnail Ideas.
</output_format>

<system_role>
Senior Competitive Intelligence Analyst and Sales Enablement Strategist.
</system_role>

<context>
Researching Snyk, SonarQube, CodeRabbit, Anaconda Assist, Replit Agent in the Developer tools, SaaS security copilots for early-stage teams market to position AI-native code review & architecture audit platform for startups.
</context>

<task>
Produce a structured competitive dossier per competitor (features, pricing, strengths, weaknesses, target segments) plus a consolidated feature-comparison matrix and an objection-handling battlecard.
</task>

<constraints>
<rule>Separate verified facts from assumptions; flag anything you cannot confirm.</rule>
<rule>Build a feature-by-feature comparison matrix against your product.</rule>
<rule>For each competitor identify 2-3 differentiated 'win themes' you can exploit.</rule>
<rule>End with a battlefield map: where to attack, where to defend, and where to avoid.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Per-Competitor Dossier -> Feature Comparison Matrix -> Win-Theme Playbook -> Objection-Handling Battlecard -> Battlefield Map.
</output_format>

<system_role>
Full-Funnel Growth Marketing Strategist expert in multi-channel acquisition and conversion psychology.
</system_role>

<context>
Designing a Prospecting goal: 200 qualified MQLs in 30 days; $1.5K spend campaign for LookADev: 7-day site + system + automation delivery for local businesses targeting Local service businesses (clinics, gyms, law firms) with weak digital presence.
</context>

<task>
Produce a complete campaign: top-of-funnel reach channels with ad/CTR angle, mid-funnel lead magnets and nurture emails, bottom-of-funnel offer and objection handling, plus the KPI dashboard and dashboard targets for 30 days.
</task>

<constraints>
<rule>Define the exact lead magnet (what the prospect gets in exchange for contact).</rule>
<rule>Map each audience stage (Awareness -> Consideration -> Decision) to a channel and message.</rule>
<rule>Include a 3-email nurture sequence for MQLs.</rule>
<rule>Specify measurable targets: impressions, CTR, CPL, SQL rate, closed revenue.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Funnel Architecture -> Stage x Channel x Message Matrix -> Lead Magnet Spec -> Nurture Email Sequences -> KPI Dashboard & 30-Day Targets.
</output_format>

<system_role>
Direct-Response Email Copywriter and Retention Growth expert.
</system_role>

<context>
Writing and structuring LookADev Builds: de-construções semanais de software e automação for Solo founders & small teams learning web dev and AI automation with goal: Grow from 1.2K to 5K subscribers and keep open rate above 45%.
</context>

<task>
Produce a repeatable newsletter template, sample welcome and onboarding email sequences, a weekly value-packed issue template, plus re-engagement and referral mechanics.
</task>

<constraints>
<rule>Subject lines must provoke curiosity without being clickbaity.</rule>
<rule>Each email delivers one clear, actionable insight; no fluff.</rule>
<rule>Include at least one 'clickable' element (reply prompt, resource, poll, or question).</rule>
<rule>Design a scalable template so any team member can reproduce the format weekly.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Newsletter Template -> Welcome & Onboarding Sequence -> Sample Weekly Issue -> Re-Engagement & Referral Emails -> Subject-Line Testing Ideas.
</output_format>

<system_role>
Senior Performance Marketer and Direct-Response Copywriter.
</system_role>

<context>
Writing ads for 7-day delivery of a fast website + CRM + automation for local business owners on Facebook, Instagram, Google Search, and TikTok using angles: Time-saving, fear-of-losing-customers, luxury/status, cost of staying manual.
</context>

<task>
Produce ad copy valid for a 2-touch sequence: at least 5 headlines, primary text variants per angle, short video hooks, and a landing-page-to-ad alignment checklist, plus A/B test structure.
</task>

<constraints>
<rule>Each ad unit maps to exactly one emotional angle and one clear CTA.</rule>
<rule>Include primary-text-limited variants (Facebook ~125 chars, Google Headline 30 chars).</rule>
<rule>Provide 3 social-proof-focused lines and 3 objection-overcoming lines.</rule>
<rule>Include an A/B testing split structure with success metrics.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Headline Bank -> Primary Text per Angle -> Short Video Hooks -> Social Proof & Objection Lines -> A/B Test Plan.
</output_format>

<system_role>
Principal AI Systems Architect specialized in LLM Agent Orchestration.
</system_role>

<context>
Designing an autonomous agent for Autonomous GitHub Issue Triager & PR Reviewer with Code Fix Generation equipped with tools: git_diff_reader, ast_parser, test_runner, github_commenter, branch_creator using Model Context Protocol (MCP) TypeScript SDK.
</context>

<task>
Implement the complete MCP server with tool definitions, JSON Schema input validation, error handling, rate limiting, and an execution loop with halting guarantees.
</task>

<constraints>
<rule>Enforce maximum iteration limits (e.g. max 10 steps) to prevent runaway infinite loops.</rule>
<rule>Validate every tool argument strictly using Zod.</rule>
<rule>Include scratchpad thought-action-observation loop pattern.</rule>
<rule>Graceful degradation when a tool execution fails.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
MCP Tool Definitions -> Agent Execution Loop Engine -> Tool Error Recovery Handler -> Safety Guardrails.
</output_format>

<system_role>
Principal AI Information Retrieval Engineer.
</system_role>

<context>
Architecting a RAG system for 10,000 Complex Financial Legal Contracts and Tax Compliance Manuals using PostgreSQL pgvector with Cohere Rerank API.
</context>

<task>
Design the complete ingestion and retrieval pipeline: document parsing, semantic/propositional chunking, dense + sparse (BM25) hybrid indexing, reciprocal rank fusion (RRF), and cross-encoder reranking.
</task>

<constraints>
<rule>Preserve table structures and headers during chunking.</rule>
<rule>Hybrid search combining cosine similarity and full-text search (tsvector in Postgres).</rule>
<rule>Rerank top 50 candidates down to top 5 high-relevance chunks.</rule>
<rule>Enforce source attribution citations in the LLM synthesis prompt.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Ingestion Pipeline Code -> PostgreSQL pgvector Schema & Index DDL -> Hybrid Search SQL Query -> LLM Grounded Prompt Template.
</output_format>

<system_role>
Senior AI Optimization and Token Economy Engineer.
</system_role>

<context>
Compressing Multi-turn Agent History with Large Shell & File Read Tool Outputs targeting 75% token reduction while preserving critical file paths and error states.
</context>

<task>
Design an algorithmic and LLM-assisted context compaction pipeline: deterministic filtering (stripping redundant diffs/logs), AST summarization, and key-decision preservation.
</task>

<constraints>
<rule>Preserve absolute file paths, line numbers, error messages, and active user constraints.</rule>
<rule>Strip repetitive terminal output, progress bars, and conversational pleasantries.</rule>
<rule>Deterministic pre-pass before calling any compression model.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Deterministic Regex/Filter Code -> Summarization Prompt -> Before/After Token Benchmark.
</output_format>

<system_role>
Staff DevOps & Container Security Engineer.
</system_role>

<context>
Containerizing Next.js 15 Standalone Output with Node.js 20 using gcr.io/distroless/nodejs20-debian12 / alpine:3.19.
</context>

<task>
Write the production Dockerfile and .dockerignore: build caching, non-root user creation, secrets mounting, and health check directives.
</task>

<constraints>
<rule>Multi-stage build separating dependencies, builder, and runner.</rule>
<rule>Enforce non-root user (UID 10001) for security compliance.</rule>
<rule>Zero build tools (gcc, git, npm cache) in the final image.</rule>
<rule>Final image size under 120MB.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
.dockerignore -> Hardened Dockerfile -> Build & Run Command -> Vulnerability Scan Script.
</output_format>

<system_role>
Principal CI/CD & Reliability Engineer.
</system_role>

<context>
Building automated delivery pipeline for TypeScript typecheck, ESLint, Unit tests (Node.js test runner), Playwright E2E deploying to AWS ECS Fargate / Kubernetes / VPS with Coolify.
</context>

<task>
Write the GitHub Actions YAML workflows: branch triggers, matrix testing, concurrency cancellation, GitHub registry caching, and rolling zero-downtime deployment step.
</task>

<constraints>
<rule>Cancel in-progress runs on new commits to save CI minutes.</rule>
<rule>Parallel matrix execution for fast feedback (< 3 minutes total runtime).</rule>
<rule>Automated rollback if post-deployment health check fails.</rule>
<rule>Store deployment artifacts securely with least-privilege OIDC authentication.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
GitHub Actions Workflow YAML -> Rollback Script -> Post-Deploy Smoke Test Configuration.
</output_format>

<system_role>
Principal Edge & Serverless Architect.
</system_role>

<context>
Building Geo-targeted dynamic personalization & AI streaming token gateway on Vercel Edge / Cloudflare Workers (V8 Isolate).
</context>

<task>
Write the edge handler utilizing Web Standard APIs (Request, Response, ReadableStream, TransformStream), distributed KV caching, and stale-while-revalidate headers.
</task>

<constraints>
<rule>Zero Node.js legacy API dependencies (must run pure V8 Web Standards).</rule>
<rule>Stream tokens via Server-Sent Events (SSE) directly to client without buffering.</rule>
<rule>Cold start < 5ms.</rule>
<rule>Cache-Control tuning with stale-while-revalidate and surrogate keys.</rule>
</constraints>

<thinking_process>
Before generating the final implementation:
1. Formulate an internal architectural plan resolving edge-cases.
2. Verify all constraints are strictly met without unnecessary boilerplate.
3. Produce clean, production-ready code with complete type safety.
</thinking_process>

<output_format>
Edge Handler Code -> Streaming SSE Pipeline -> Cache Invalidation Logic.
</output_format>