raw_prompt: Review this Python function for bugs and performance issues

formula: x(t) = Σ x(nT) · sinc((t - nT) / T)

T: specification-axis

t: PERSONA

x: You are a senior Python engineer with 12 years of experience in performance optimization and security auditing. You review code at the function level with focus on correctness, edge cases, and algorithmic complexity.

t: CONTEXT

x: This function is part of a payment processing pipeline handling 50,000 transactions per hour. It runs in production on Python 3.11 with PostgreSQL 15. The team has reported intermittent 504 timeouts traced to this function.

t: DATA

x:
def process_payment(user_id, amount):
    db = get_connection()
    user = db.query(f'SELECT * FROM users WHERE id = {user_id}')
    if user['balance'] >= amount:
        db.execute(f'UPDATE users SET balance = balance - {amount} WHERE id = {user_id}')
        db.execute(f'INSERT INTO transactions VALUES ({user_id}, {amount}, NOW())')
        return {'status': 'ok'}
    return {'status': 'insufficient'}

t: CONSTRAINTS

x: Identify ALL bugs ranked by severity (critical > high > medium > low). For each bug: state the exact line, the vulnerability class (CWE number if applicable), the exploit scenario, and the fix as a code diff. Check specifically for: SQL injection, race conditions, missing transaction boundaries, connection leaks, type coercion errors, missing error handling, and N+1 queries. Do not suggest stylistic changes. Do not suggest changes unrelated to bugs or performance. Maximum 500 words.

t: FORMAT

x: Return a numbered list. Each entry: [SEVERITY] Line N: one-sentence description. Vulnerability: CWE-XXX. Exploit: one sentence. Fix: code diff (before/after). End with a summary table: Bug | Severity | CWE | Fixed.

t: TASK

x: Review the process_payment function. Find every bug and performance issue. Provide exact fixes.

domain: Software Engineering


raw_prompt: My React app crashes when I click the submit button

x: You are a React debugging specialist who diagnoses runtime errors from stack traces and component trees. You identify root causes in under 3 questions.

x: React 18.2 app with TypeScript 5.0, using React Hook Form 7.45 and Zod validation. The form worked in v2.1 but crashes since v2.2 deployment on March 15, 2026. No changes to the form component itself between versions.

x:
Error: TypeError: Cannot read properties of undefined (reading 'email')
  at SubmitHandler (ContactForm.tsx:47)
  at HTMLFormElement.handleSubmit (react-hook-form.js:1284)
Component: <ContactForm schema={contactSchema} onSubmit={handleContact} />
The contactSchema was moved from local file to shared @company/schemas package in v2.2.

x: Diagnose from the stack trace and context provided -- do not ask clarifying questions. Identify the exact root cause in 1 sentence. Trace the causal chain: what changed in v2.2, why it breaks the read of 'email', and what the fix is. Provide the fix as a code diff. If multiple possible causes exist, rank by probability and explain why the top candidate is most likely. Do not suggest 'try adding console.log' or generic debugging steps.

x: Root Cause: one sentence. Causal Chain: numbered steps (max 5). Fix: code diff. Verification: one command to confirm the fix works.

x: Diagnose why the ContactForm crashes on submit since v2.2 and provide the exact fix.


raw_prompt: Research the AI coding assistant market for me

x: You are a technology market analyst at a top-3 consulting firm specializing in developer tools and AI infrastructure. You produce investment-grade market maps with TAM/SAM/SOM analysis.

x: A Series B developer tools company ($12M ARR) is evaluating whether to build an AI coding assistant feature. They need to understand the competitive landscape as of Q1 2026, market size projections, and defensible niches before their board meeting on April 5, 2026.

x: Known competitors: GitHub Copilot, Cursor, Codeium, Tabnine, Amazon CodeWhisperer, Sourcegraph Cody. The company's existing product is a code review platform with 8,000 enterprise customers. Their differentiation is deep integration with CI/CD pipelines and compliance workflows.

x: Use only publicly available data (earnings reports, press releases, Crunchbase, published analyst reports). For market size, cite the source and date of each number. Clearly label estimates vs confirmed figures. Analyze exactly 3 strategic options: build, partner, acquire. For each option: investment required (range), time to market, risk level (1-5), expected ROI at 24 months. Do not use superlatives ('massive market', 'huge opportunity'). Every claim needs a number.

x: 1. Market Map: table with competitor | funding | est. ARR | key differentiator | threat level (1-5). 2. TAM/SAM/SOM: three numbers with sources. 3. Strategic Options: 3-row comparison table. 4. Recommendation: 1 paragraph with the recommended path and why.

x: Produce a board-ready competitive analysis of the AI coding assistant market with a strategic recommendation for a code review platform company.

domain: Business Strategy


raw_prompt: Review this SaaS contract for any issues

x: You are a technology transactions attorney with 15 years of experience reviewing SaaS agreements for enterprise buyers. You have reviewed over 500 SaaS contracts and specialize in data protection, liability caps, and termination clauses.

x: Our company (5,000 employees, healthcare sector, HIPAA-regulated) is evaluating a 3-year SaaS contract worth $840,000 total from a Series C vendor for an internal analytics platform. The vendor processes PHI as part of the service. Contract renewal deadline is April 1, 2026.

x: Key contract sections: Liability cap is set at 'fees paid in the prior 12 months'. Data processing clause states vendor 'may use aggregated, de-identified data for product improvement'. Termination requires 180-day written notice. SLA guarantees 99.5% uptime with credits capped at 5% of monthly fees. Indemnification is mutual but excludes IP infringement by vendor's third-party components. Governing law: Delaware.

x: Evaluate ONLY from the buyer's perspective. Flag every clause that creates risk for a HIPAA-regulated entity. For each flagged clause: state the risk in 1 sentence, rate severity (critical/high/medium/low), provide the specific redline language you would propose, and cite the relevant regulation or standard (HIPAA, SOC 2, GDPR if applicable). Do not provide general legal education. Do not disclaim that you are not a lawyer. Focus exclusively on actionable redlines.

x: Numbered list of flagged clauses, each with: [SEVERITY] Clause name -- Risk: one sentence. Redline: exact proposed language change. Basis: regulation/standard. End with a negotiation priority matrix: must-have vs nice-to-have changes.

x: Review the SaaS contract terms and produce actionable redlines prioritized for a HIPAA-regulated healthcare buyer.

domain: Legal


raw_prompt: What could cause persistent fatigue and joint pain?

x: You are a clinical decision support system trained on Harrison's Principles of Internal Medicine and UpToDate. You generate differential diagnoses ranked by posterior probability given the presented symptoms and demographics.

x: 38-year-old female presenting to primary care. Symptoms onset 4 months ago, progressive. No prior autoimmune history. Family history: mother has Hashimoto's thyroiditis. Lives in northeastern United States. No recent travel. Works as a landscape designer (outdoor exposure). Current medications: none.

x: Symptoms: fatigue (daily, severity 7/10), bilateral symmetric joint pain (MCPs, PIPs, wrists), morning stiffness lasting 90 minutes, low-grade fever (99.8F intermittent), unintentional weight loss of 8 lbs over 4 months. Labs: ESR 42 mm/hr (elevated), CRP 2.8 mg/dL (elevated), CBC normal, TSH normal.

x: Generate a differential diagnosis with exactly 5 conditions ranked by likelihood. For each: state the pre-test probability estimate (percentage), list the 3 most discriminating findings that support or argue against it, and specify the single most informative next test to confirm or rule it out. Account for the geographic location (Lyme disease endemic area) and family history (autoimmune predisposition). Do not provide treatment recommendations. Do not diagnose -- generate differentials only. Include at least 1 non-autoimmune etiology.

x: Table: Rank | Diagnosis | Pre-test Probability | Supporting Findings | Arguing Against | Key Next Test. Below the table: recommended test ordering sequence (which test first and why).

x: Generate a ranked differential diagnosis for this presentation and recommend the optimal diagnostic workup sequence.

domain: Healthcare


raw_prompt: Analyze whether we should raise a Series B round

x: You are a startup CFO advisor who has guided 40+ SaaS companies through Series A to Series C fundraising. You evaluate fundraising readiness using SaaS-specific metrics and market timing signals.

x: B2B SaaS company, 2.5 years post-Series A ($8M raised at $32M pre-money). Current date: March 2026. The fundraising market for B2B SaaS has tightened since 2023 but is recovering for companies with strong unit economics. Board is split on timing: raise now at lower valuation vs wait 6 months for better metrics.

x: ARR: $4.2M (was $1.8M at Series A). MoM growth: 8% (last 6 months average). Gross margin: 78%. Net revenue retention: 118%. CAC payback: 14 months. Burn multiple: 1.8x. Runway: 11 months at current burn. Logo churn: 2.1% monthly. ACV: $18,000. Total customers: 230. Pipeline: $1.2M in qualified opportunities.

x: Evaluate fundraising readiness on exactly 5 dimensions: growth rate, unit economics, market timing, runway pressure, and competitive positioning. For each dimension: score 1-10, state the benchmark (median Series B SaaS company), and indicate whether this metric helps or hurts the raise. Model exactly 2 scenarios: (A) raise now targeting $15-20M at $60-80M pre-money, (B) wait 6 months assuming current growth trajectory holds. For each scenario: expected dilution, runway impact, and valuation sensitivity. Do not recommend -- present the analysis for board decision.

x: 1. Readiness Scorecard: 5-row table (Dimension | Score | Benchmark | Verdict). 2. Scenario A: 3 metrics in a box. 3. Scenario B: 3 metrics in a box. 4. Risk Matrix: 2x2 (raise now risks vs wait risks, upside vs downside).

x: Produce a Series B fundraising readiness analysis with two timing scenarios for board presentation.

domain: Finance


raw_prompt: Write a blog post about our new product feature

x: You are a B2B SaaS content strategist who writes product launch posts that rank on page 1 for feature-specific long-tail keywords. Your writing style: clear, technical, zero fluff, every paragraph earns its place.

x: We are launching real-time collaboration in our project management tool (competitor to Asana/Monday.com). Target audience: engineering managers at 50-500 person companies who currently use Google Docs alongside their PM tool. Publishing on our blog (DA 45, 12,000 monthly visitors). Goal: 500 organic visits in first 30 days.

x: Feature: real-time collaborative editing in task descriptions, comments, and documentation. Tech: CRDT-based (no conflicts, works offline). Differentiator: inline code blocks with syntax highlighting (competitors only have rich text). Beta data: 340 users, 89% daily active rate, average session increased from 12 to 23 minutes. Target keyword: 'project management tool with real-time collaboration'.

x: Word count: 1,200-1,500. Include the target keyword in: title, H1, first paragraph, one H2, meta description. Use exactly 4 H2 sections. Include 1 customer quote (fabricate a realistic one attributed to 'Engineering Manager at a 200-person fintech'). Include 1 comparison table (us vs Asana vs Monday.com on collaboration features). No buzzwords: do not use 'revolutionary', 'game-changing', 'seamless', 'leverage', or 'unlock'. Write at an 8th grade reading level (Flesch-Kincaid). End with a CTA to start a 14-day free trial.

x: Title (with keyword) | Meta description (155 chars) | Body with 4 H2 sections | Comparison table | Customer quote block | CTA button text. Deliver as markdown.

x: Write the product launch blog post for real-time collaboration feature, optimized for the target keyword.

domain: Marketing


raw_prompt: Help me plan the launch of our mobile app

x: You are a product launch strategist who has executed 20+ B2C mobile app launches including 3 that reached top-10 in their App Store category within the first week. You plan launches in 4 phases: pre-launch, launch day, week 1, month 1.

x: Fitness tracking app targeting 25-40 year old urban professionals. We have 8,000 email waitlist signups, 2,400 beta testers (4.6 star average rating), and $50,000 launch marketing budget. Launch date: April 15, 2026. We are a team of 6 (2 engineers, 1 designer, 1 marketer, 1 founder/CEO, 1 customer support). Competitors: Strava, Nike Run Club, Fitbit.

x: Beta metrics: 68% D7 retention, 42% D30 retention, average 4.2 sessions/week, top feature usage: AI workout suggestions (78% of users), social challenges (61%), progress photos (54%). App Store Optimization: primary keyword 'AI fitness tracker' has 2,400 monthly searches with medium competition. Current App Store listing is drafted but not optimized.

x: Plan must fit within $50,000 budget with exact dollar allocation per channel. Every task must have an owner (one of the 6 team members by role), a deadline (specific date relative to April 15 launch), and a success metric. Include exactly 3 contingency plans for: (1) App Store review rejection, (2) server overload on day 1, (3) negative press/reviews. Do not suggest hiring additional staff. Do not suggest activities requiring more than 2 weeks lead time from today (March 22, 2026). Prioritize activities by expected impact on day-1 downloads.

x: Phase timeline: Gantt-style table with task | owner | deadline | budget | success metric. Budget allocation: pie chart data (channel | amount | expected ROI). Contingency plans: trigger | action | owner | max response time. Launch day hour-by-hour schedule.

x: Create the complete launch plan for April 15 with budget allocation, task assignments, and contingency plans.

domain: Product Management


raw_prompt: Analyze our user churn data and find patterns

x: You are a product analytics lead who specializes in churn prediction and retention analysis for subscription SaaS products. You use cohort analysis, survival curves, and feature importance ranking to identify actionable churn drivers.

x: B2B SaaS product with 3,200 active accounts on monthly subscriptions ($49-$299/month). Churn spiked from 3.2% to 5.8% monthly over the last quarter (Q4 2025). The product team shipped 3 major features in Q4 and changed the onboarding flow on November 1, 2025. Support ticket volume increased 40% in the same period.

x: Churned accounts Q4: 412. Breakdown by plan: Starter ($49): 58% of churn, Pro ($149): 31%, Enterprise ($299): 11%. Churned accounts by tenure: <3 months: 47%, 3-12 months: 35%, >12 months: 18%. Feature adoption among churned users: new dashboard (12%), API v2 (8%), team spaces (23%). NPS score for churned users (exit survey, 34% response rate): average 4.2. Top exit survey reasons: 'too complicated' (38%), 'missing integration' (24%), 'too expensive' (21%), 'switched to competitor' (17%).

x: Perform 3 specific analyses: (1) cohort analysis comparing pre- vs post-November 1 onboarding change, (2) survival curve comparison by plan tier, (3) churn driver ranking by information gain. For each analysis: state the method, show the expected output structure, identify the top finding, and recommend 1 specific action. Quantify the revenue impact of the churn spike ($X MRR lost). Do not recommend 'collect more data' as a primary action. Every recommendation must be implementable within 2 weeks by a product team of 4.

x: Executive summary: 3 bullet points. Analysis 1: cohort table + finding. Analysis 2: survival comparison + finding. Analysis 3: ranked feature importance + finding. Revenue impact: single number. Action plan: 3 prioritized actions with expected churn reduction (percentage points).

x: Analyze the Q4 churn spike, identify the top 3 drivers, and recommend 3 actions with expected impact.

domain: Data Science


raw_prompt: Create a response template for angry customers who want refunds

x: You are a customer support operations manager who designs response templates that achieve 85%+ CSAT on escalated tickets. You follow the HEARD framework: Hear, Empathize, Apologize, Resolve, Diagnose.

x: SaaS company ($8M ARR) selling project management software. Refund policy: full refund within 30 days, pro-rated after 30 days, no refund after 90 days. Average ticket resolution: 4.2 hours. Current CSAT on refund tickets: 62% (company target: 80%). Support team: 5 agents, all Tier 1. Tier 2 escalation to team lead.

x: Top 5 refund request triggers: (1) billed after cancellation attempt (34%), (2) feature removed or changed (22%), (3) service outage impact (18%), (4) competitor switch (15%), (5) budget cuts (11%). Average refund ticket sentiment score: -0.72 (scale -1 to +1). Refund approval rate: 73%. Average refund amount: $127.

x: Create exactly 5 templates, one per trigger type. Each template must: follow the HEARD framework in order, include merge fields for {customer_name}, {product_name}, {amount}, {billing_date}, {agent_name}. Keep each template under 150 words. Include a decision tree for when to approve vs escalate: approve immediately (conditions), escalate to Tier 2 (conditions), deny with alternative (conditions). Never use: 'unfortunately', 'per our policy', 'as previously stated', 'I understand your frustration but'. Tone: direct, warm, solution-first. Each template must offer exactly 2 resolution options.

x: 5 templates in order (one per trigger). Each template: [TRIGGER TYPE] | Word count | HEARD step markers in the text. Decision tree as a flowchart (text-based). Escalation criteria table: Condition | Action | SLA.

x: Create 5 refund response templates with a decision tree for approval/escalation routing.

domain: Customer Success


raw_prompt: Design a REST API for a task management system

x: You are an API architect who designs RESTful APIs following OpenAPI 3.1 specification. You have designed APIs serving 100M+ requests/day and prioritize developer experience, consistency, and backward compatibility.

x: Building a task management API for a B2B SaaS product. Expected load: 10,000 concurrent users, 500 requests/second peak. Must support multi-tenancy (workspace isolation), real-time updates via webhooks, and integration with Slack, Jira, and GitHub. Authentication: OAuth 2.0 with JWT. Deployment: Kubernetes on AWS.

x: Core entities: Workspace, Project, Task, Comment, User, Label, Attachment. Relationships: Workspace has many Projects, Project has many Tasks, Task has many Comments and Labels (many-to-many), User belongs to many Workspaces. Task fields: title, description, status (todo/in-progress/done/archived), priority (1-4), assignee, due_date, created_at, updated_at. Required operations: CRUD on all entities, bulk task updates, task search with filters, activity timeline.

x: Follow these conventions strictly: resource naming in plural lowercase (e.g., /tasks not /task), consistent pagination using cursor-based approach (not offset), standard error format with error code + message + details array, rate limiting headers on every response (X-RateLimit-*), ETag-based caching for GET endpoints, HATEOAS links for discoverability. Design exactly 15 endpoints covering the core operations. Include request/response schemas for the 3 most complex endpoints. Specify HTTP status codes for success AND the 3 most likely error cases per endpoint. Do not use query parameters for required filters -- use path segments.

x: Endpoint table: Method | Path | Description | Auth | Rate Limit. Followed by 3 detailed endpoint specs with request body schema, response schema, and error cases. Pagination example. Error format example.

x: Design the complete REST API surface for the task management system with 15 endpoints, pagination strategy, and error handling.

domain: Software Architecture


raw_prompt: Design the architecture for a real-time notification system

x: You are a distributed systems architect who designs event-driven architectures at scale. You have built notification systems handling 1B+ events/day at companies with 50M+ users. You evaluate trade-offs using CAP theorem and document decisions as ADRs.

x: E-commerce platform with 2M daily active users. Current notification system is a monolithic cron job that sends batch emails every 15 minutes. Requirements: real-time push notifications (mobile + web), email digests, in-app notification center. Must support: order updates, price drop alerts, back-in-stock alerts, promotional campaigns. SLA: 99.9% delivery within 30 seconds for transactional notifications.

x: Current volume: 8M notifications/day. Projected: 25M/day within 12 months. Peak: 10x during flash sales (250M/day events). Infrastructure: AWS, Kubernetes, PostgreSQL, Redis. Budget: $15,000/month for notification infrastructure. Team: 3 backend engineers, 1 DevOps.

x: Design must handle 10x peak without pre-scaling. Use only AWS-native or open-source components (no vendor lock-in to Twilio, SendGrid, etc. for core architecture -- these are acceptable as leaf-node delivery providers only). Provide exactly 3 Architecture Decision Records (ADRs): message broker choice, delivery guarantee strategy, and storage/query pattern for notification center. Each ADR must include: context, options considered (minimum 3), decision, consequences. Include a failure mode analysis: what happens when each component fails? Must fit within $15,000/month budget -- show estimated cost breakdown.

x: C4 Level 2 diagram (text description of containers). 3 ADRs in standard format. Data flow for 1 notification lifecycle (order shipped). Failure mode table: Component | Failure | Impact | Mitigation | RTO. Cost breakdown table: Component | Service | Monthly Cost.

x: Design the real-time notification system architecture with ADRs, failure analysis, and cost breakdown fitting the $15K/month budget.


raw_prompt: Our database is slow, help us fix it

x: You are an SRE incident commander who has resolved 200+ production database incidents. You follow a structured triage: identify blast radius, stabilize, diagnose root cause, remediate, postmortem.

x: Production PostgreSQL 15 database on AWS RDS (db.r6g.2xlarge, 8 vCPU, 64GB RAM). Serving a B2B SaaS application with 1,200 concurrent users. Incident started 45 minutes ago. Customer-facing impact: API response times increased from 120ms p95 to 3,200ms p95. Error rate: 12% (up from 0.1%). PagerDuty alert triggered at severity P1.

x: Observations: CPU usage: 94% (normal: 35%). Active connections: 487 (max_connections: 500, normal: 120). Disk IOPS: 12,000 (provisioned: 10,000). Top query by time: SELECT * FROM events WHERE user_id = $1 AND created_at > $2 ORDER BY created_at DESC -- running 3,400 times/minute (up from 200/min). pg_stat_activity shows 340 queries in 'active' state on the events table. The events table: 180M rows, last VACUUM was 3 days ago, bloat estimate: 40%. A new feature was deployed 2 hours ago that added an 'activity feed' hitting this query.

x: Provide a triage sequence with exact commands to run (psql, AWS CLI, or shell commands). Separate actions into: immediate stabilization (next 5 minutes), root cause confirmation (next 15 minutes), remediation (next 1 hour). Every action must have: the exact command, what it checks, the expected output if the hypothesis is correct, and the rollback command if it makes things worse. Do not suggest 'upgrade the instance' as a first action. Do not suggest changes that require a maintenance window. Prioritize actions by impact/effort ratio.

x: Phase 1 (0-5 min): numbered stabilization commands. Phase 2 (5-20 min): diagnostic commands with expected output. Phase 3 (20-60 min): remediation steps. Decision tree: if X then Y, else Z. Postmortem template: timeline, root cause, action items.

x: Produce the incident response runbook for this PostgreSQL performance crisis with exact commands for each phase.

domain: DevOps/SRE


raw_prompt: Create an interview process for a senior backend engineer

x: You are a technical hiring manager who has conducted 500+ engineering interviews and built interview processes achieving 90%+ new hire retention at 12 months. You design structured interviews with calibrated rubrics to minimize bias.

x: Series B startup (80 employees, 25 engineers) hiring a senior backend engineer for the payments team. Tech stack: Go, PostgreSQL, Kafka, Kubernetes, AWS. The role requires: designing APIs, owning a microservice, mentoring 2 junior engineers, and participating in on-call rotation. Compensation: $180-220K base. Timeline: fill the role by May 1, 2026. Current pipeline: 45 applicants, need to filter to 8 phone screens.

x: Team gaps: no one with deep Kafka experience (current team learned from docs), API design is inconsistent across services, on-call is currently handled by 3 people (need a 4th). Previous hire (6 months ago) passed all interviews but struggled with ambiguity and ownership -- the process failed to test for these traits. Hiring committee: engineering manager, 2 senior engineers, VP Engineering (final).

x: Design exactly 5 interview stages (resume screen through final). Total candidate time: maximum 5 hours across all stages. Each stage must have: exact duration, interviewer(s), competencies tested (maximum 3 per stage), 2 specific questions with ideal answer criteria, a scoring rubric (1-4 scale with behavioral anchors for each score), and a pass/fail threshold. Ensure the process tests for the failure mode identified (ambiguity tolerance and ownership) -- dedicate at least 1 full stage to this. Include a calibration exercise: provide 2 sample candidate profiles and the expected score across all stages. Do not include trick questions or brainteasers.

x: Stage table: Stage | Duration | Interviewer | Competencies | Pass Threshold. Per stage: 2 questions with rubric (Score 1/2/3/4 behavioral descriptions). Calibration: 2 candidate profiles scored through all stages. Scorecard template for the hiring committee debrief.

x: Design the complete 5-stage interview process with questions, rubrics, and calibration profiles for the senior backend engineer role.

domain: Human Resources


raw_prompt: Compare our product to our competitors

x: You are a competitive intelligence analyst who produces battle cards used by sales teams to win deals against specific competitors. You analyze products on 4 axes: feature parity, pricing, positioning, and customer sentiment.

x: We sell an observability platform ($2.5M ARR) competing for mid-market deals (200-2000 employees). Win rate has dropped from 45% to 31% in the last quarter. Sales reports indicate 3 primary competitors appearing in 80% of lost deals: Datadog, Grafana Cloud, and New Relic. The sales team of 8 AEs needs updated battle cards by April 1, 2026.

x: Our product: full-stack observability (logs, metrics, traces), $15/host/month, no user-based pricing, unlimited retention, self-hosted option available. Key wins: companies with >500 hosts (cost advantage), compliance-heavy industries (self-hosted), teams with existing Prometheus/Grafana investments (migration tools). Key losses: companies wanting APM (we lack code-level tracing), teams wanting AI-powered alerting (competitors ahead), deals where Datadog is incumbent.

x: Create exactly 3 battle cards (one per competitor). Each battle card must contain: positioning comparison (2 sentences each), feature comparison table (exactly 8 features, scored as 'ahead'/'parity'/'behind' for each), pricing comparison at 3 scale points (100, 500, 1000 hosts), top 3 objections the competitor's sales team makes about us (with rebuttals), top 3 trap questions to ask prospects to highlight competitor weaknesses, and the ideal customer profile where we win against this specific competitor. Use only publicly available pricing and feature data. Mark any estimate with [EST]. Do not disparage competitors -- focus on factual differentiation.

x: 3 battle cards, each as a structured section: Header (Competitor name + one-line positioning). Feature table: 8 rows. Pricing table: 3 scale points. Objection/Rebuttal: 3 pairs. Trap Questions: 3 with expected outcome. Win Profile: 1 paragraph.

x: Create 3 competitor battle cards for Datadog, Grafana Cloud, and New Relic to help the sales team improve win rate from 31% back to 45%.