to AI Feature QA in Rork Apps 2026— Prompt Regression Testing, Hallucination Detection, and CI/CD Integration

// src/ai/prompts/healthCoachPrompt.ts
export interface HealthCoachInput {
  userGoal: 'weight_loss' | 'muscle_gain' | 'general_fitness';
  currentWeightKg: number;
  targetWeightKg: number;
  activityLevel: 'sedentary' | 'moderate' | 'active';
  availableMinutesPerDay: number;
}
 
export function buildHealthCoachPrompt(input: HealthCoachInput): string {
  const goalDescriptions = {
    weight_loss: 'sustainable weight loss',
    muscle_gain: 'muscle building and strength',
    general_fitness: 'overall fitness and energy levels',
  };
 
  const activityContext = {
    sedentary: 'currently not exercising regularly',
    moderate: 'exercising 2-3 times per week',
    active: 'exercising 4+ times per week',
  };
 
  return `You are a certified personal trainer and registered dietitian.
Provide practical, evidence-based advice for the person described below.
Be specific and actionable. Do not recommend anything unsafe or extreme.
Keep your response under 180 words.
 
Goal: ${goalDescriptions[input.userGoal]}
Current weight: ${input.currentWeightKg}kg, target: ${input.targetWeightKg}kg
Activity: ${activityContext[input.activityLevel]}
Available time: ${input.availableMinutesPerDay} minutes per day
 
Respond in this exact format:
Priority: [The single most important thing to focus on this week]
Weekly Plan: [2-3 specific actions with concrete details]
Realistic Expectation: [What progress looks like in 4 weeks if they follow the plan]`;
}

// src/ai/prompts/__tests__/healthCoachPrompt.test.ts
import { buildHealthCoachPrompt, HealthCoachInput } from '../healthCoachPrompt';
 
const baseInput: HealthCoachInput = {
  userGoal: 'weight_loss',
  currentWeightKg: 82,
  targetWeightKg: 72,
  activityLevel: 'moderate',
  availableMinutesPerDay: 45,
};
 
describe('buildHealthCoachPrompt', () => {
  it('interpolates all user parameters correctly', () => {
    const prompt = buildHealthCoachPrompt(baseInput);
    expect(prompt).toContain('82kg');
    expect(prompt).toContain('72kg');
    expect(prompt).toContain('45 minutes per day');
    expect(prompt).toContain('sustainable weight loss');
  });
 
  it('specifies word count constraint', () => {
    const prompt = buildHealthCoachPrompt(baseInput);
    expect(prompt).toContain('180 words');
  });
 
  it('includes all three required output sections', () => {
    const prompt = buildHealthCoachPrompt(baseInput);
    expect(prompt).toContain('Priority:');
    expect(prompt).toContain('Weekly Plan:');
    expect(prompt).toContain('Realistic Expectation:');
  });
 
  it('handles all goal types without throwing', () => {
    const goals: HealthCoachInput['userGoal'][] = [
      'weight_loss', 'muscle_gain', 'general_fitness'
    ];
    expect(() =>
      goals.map(goal => buildHealthCoachPrompt({ ...baseInput, userGoal: goal }))
    ).not.toThrow();
  });
 
  it('handles boundary values without throwing', () => {
    expect(() => buildHealthCoachPrompt({
      ...baseInput,
      availableMinutesPerDay: 0,
      currentWeightKg: baseInput.targetWeightKg, // at target weight
    })).not.toThrow();
  });
 
  it('does not include empty or undefined sections', () => {
    const prompt = buildHealthCoachPrompt(baseInput);
    expect(prompt).not.toContain('undefined');
    expect(prompt).not.toContain('[object Object]');
    expect(prompt).not.toMatch(/:\s*\n/); // No empty values after colons
  });
});

// src/ai/evaluation/regressionTest.ts
import Anthropic from '@anthropic-ai/sdk';
 
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
 
export interface AITestCase {
  id: string;
  description: string;
  userQuery: string;
  aiResponse: string;     // The response under evaluation
  evaluationCriteria: string[];
  minimumScore: number;   // 0-10 scale, typically 7 for production features
  tags: string[];         // For filtering (e.g., 'health', 'edge-case', 'adversarial')
}
 
export interface EvaluationResult {
  caseId: string;
  score: number;
  reasoning: string;
  passed: boolean;
  evaluatedAt: string;
  modelUsed: string;
}
 
export async function evaluateResponse(
  testCase: AITestCase
): Promise<EvaluationResult> {
  const criteriaText = testCase.evaluationCriteria
    .map((criterion, i) => `${i + 1}. ${criterion}`)
    .join('\n');
 
  const judgePrompt = `You are calibrating AI assistant quality for a health and fitness app.
Evaluate the response below based strictly on the provided criteria.
 
Use this scale:
- 9-10: Exceptional — specific, safe, actionable, perfectly calibrated
- 7-8: Good — meets all criteria, minor room for improvement  
- 5-6: Acceptable — meets basic criteria but has notable weaknesses
- 3-4: Below standard — misses important criteria or contains issues
- 0-2: Failing — unsafe, incorrect, or fundamentally unhelpful
 
## User Query
${testCase.userQuery}
 
## AI Response Being Evaluated
${testCase.aiResponse}
 
## Evaluation Criteria
${criteriaText}
 
Respond with JSON only, no other text:
{
  "score": <integer 0-10>,
  "reasoning": "<2-3 sentences explaining the score with specific references to the response>"
}`;
 
  const judgeModel = 'claude-haiku-4-5-20251001';
  
  const response = await client.messages.create({
    model: judgeModel,
    max_tokens: 300,
    temperature: 0,
    messages: [{ role: 'user', content: judgePrompt }],
  });
 
  const content = response.content[0];
  if (content.type \!== 'text') {
    throw new Error('Judge returned non-text response');
  }
 
  // Handle cases where Claude adds markdown fences around JSON
  const jsonMatch = content.text.match(/\{[\s\S]*\}/);
  if (\!jsonMatch) {
    throw new Error(`Could not parse judge response: ${content.text.slice(0, 200)}`);
  }
 
  const parsed = JSON.parse(jsonMatch[0]) as { score: number; reasoning: string };
 
  return {
    caseId: testCase.id,
    score: parsed.score,
    reasoning: parsed.reasoning,
    passed: parsed.score >= testCase.minimumScore,
    evaluatedAt: new Date().toISOString(),
    modelUsed: judgeModel,
  };
}
 
export async function runSampledRegressionSuite(
  testCases: AITestCase[],
  options: {
    samplingRate?: number;   // 0.0-1.0, default 1.0
    passRateThreshold?: number; // 0-100, default 80
    tags?: string[];          // Filter to specific test subsets
  } = {}
): Promise<{ passRate: number; results: EvaluationResult[] }> {
  const { samplingRate = 1.0, passRateThreshold = 80, tags } = options;
 
  // Filter by tags if specified
  const filtered = tags
    ? testCases.filter(tc => tags.some(tag => tc.tags.includes(tag)))
    : testCases;
 
  // Deterministic sampling for reproducibility (sort by id, then slice)
  const sorted = [...filtered].sort((a, b) => a.id.localeCompare(b.id));
  const sampleSize = Math.max(1, Math.floor(sorted.length * samplingRate));
  const sampled = sorted.slice(0, sampleSize);
 
  console.log(`Running ${sampled.length}/${filtered.length} test cases`);
 
  const results: EvaluationResult[] = [];
  
  // Run with concurrency limit to avoid rate limiting
  const CONCURRENCY = 3;
  for (let i = 0; i < sampled.length; i += CONCURRENCY) {
    const batch = sampled.slice(i, i + CONCURRENCY);
    const batchResults = await Promise.allSettled(
      batch.map(tc => evaluateResponse(tc))
    );
    
    batchResults.forEach((result, j) => {
      if (result.status === 'fulfilled') {
        results.push(result.value);
        const status = result.value.passed ? '✅' : '❌';
        console.log(
          `${status} [${result.value.caseId}] ${result.value.score}/10 — ${result.value.reasoning}`
        );
      } else {
        console.error(`⚠️ [${batch[j].id}] Evaluation error:`, result.reason);
      }
    });
 
    // Small delay between batches to be respectful of rate limits
    if (i + CONCURRENCY < sampled.length) {
      await new Promise(resolve => setTimeout(resolve, 200));
    }
  }
 
  const passCount = results.filter(r => r.passed).length;
  const passRate = results.length > 0 ? (passCount / results.length) * 100 : 0;
 
  console.log(`\n--- Regression Suite Summary ---`);
  console.log(`Pass rate: ${passCount}/${results.length} (${passRate.toFixed(1)}%)`);
  console.log(`Threshold: ${passRateThreshold}%`);
  
  if (passRate < passRateThreshold) {
    const failedCases = results.filter(r => \!r.passed);
    console.error('\nFailed cases:');
    failedCases.forEach(r => {
      console.error(`  - [${r.caseId}] Score: ${r.score}/10: ${r.reasoning}`);
    });
    throw new Error(`Pass rate ${passRate.toFixed(1)}% below threshold ${passRateThreshold}%`);
  }
 
  return { passRate, results };
}

// src/ai/safety/hallucinationGuard.ts
import Anthropic from '@anthropic-ai/sdk';
 
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
 
interface SafetyCheckResult {
  isSafe: boolean;
  confidence: 'high' | 'medium' | 'low';
  concerns: string[];
  riskLevel: 'none' | 'low' | 'medium' | 'high';
}
 
export async function checkResponseSafety(
  query: string,
  response: string,
  allowedScope: string,
): Promise<SafetyCheckResult> {
  const safetyPrompt = `You are a safety evaluator for an AI assistant app. 
Analyze this AI response for potential issues before it's shown to users.
 
## Allowed Scope for This Feature
${allowedScope}
 
## User's Question
${query}
 
## AI Response to Evaluate
${response}
 
## Check for these specific issues:
1. Does the response exceed the allowed scope (e.g., providing medical diagnoses when only general wellness advice is permitted)?
2. Does it make specific quantitative claims (statistics, dosages, timescales) without qualifying language?
3. Does it use language that overstates certainty ("always", "never", "guaranteed", "proven to") without scientific backing?
4. Could acting on any part of this response cause direct harm to the user?
5. Does it recommend actions that require professional supervision (medical procedures, extreme diets, etc.)?
 
## Respond with JSON only:
{
  "isSafe": true/false,
  "confidence": "high"/"medium"/"low",
  "riskLevel": "none"/"low"/"medium"/"high",
  "concerns": ["specific concern 1", "specific concern 2"]
}`;
 
  try {
    const evaluation = await client.messages.create({
      model: 'claude-haiku-4-5-20251001',
      max_tokens: 400,
      temperature: 0,
      messages: [{ role: 'user', content: safetyPrompt }],
    });
 
    const text = evaluation.content[0].type === 'text' 
      ? evaluation.content[0].text 
      : '';
    
    const jsonMatch = text.match(/\{[\s\S]*\}/);
    if (\!jsonMatch) {
      // If we can't parse the safety check, default to conservative (block)
      return {
        isSafe: false,
        confidence: 'low',
        riskLevel: 'medium',
        concerns: ['Safety evaluation parse failure — defaulting to blocked'],
      };
    }
 
    return JSON.parse(jsonMatch[0]) as SafetyCheckResult;
  } catch (error) {
    // Any exception in safety checking → block the response
    console.error('Safety check failed with exception:', error);
    return {
      isSafe: false,
      confidence: 'low',
      riskLevel: 'medium',
      concerns: ['Safety check threw an exception — response blocked'],
    };
  }
}
 
// Higher-level wrapper used at the API boundary in your Rork app
export async function createSafeAIResponse(options: {
  userQuery: string;
  generateResponse: () => Promise<string>;
  featureScope: string;
  fallbackMessage: string;
  onFiltered?: (concerns: string[], riskLevel: string) => void;
}): Promise<string> {
  const rawResponse = await options.generateResponse();
  
  const safetyCheck = await checkResponseSafety(
    options.userQuery,
    rawResponse,
    options.featureScope,
  );
 
  if (\!safetyCheck.isSafe) {
    if (options.onFiltered) {
      options.onFiltered(safetyCheck.concerns, safetyCheck.riskLevel);
    }
    return options.fallbackMessage;
  }
 
  // For medium-confidence checks, add a disclaimer even on safe responses
  if (safetyCheck.confidence === 'low' && safetyCheck.riskLevel \!== 'none') {
    return rawResponse + '\n\n_Note: This is general guidance, not professional advice._';
  }
 
  return rawResponse;
}

# .github/workflows/ai-quality.yml
name: AI Quality Gates
 
on:
  push:
    branches: ['*']
  pull_request:
    branches: ['main']
  schedule:
    # Full regression suite runs every Sunday at 2 AM UTC (weekly monitoring)
    - cron: '0 2 * * 0'
 
jobs:
  prompt-unit-tests:
    name: "Layer 1: Prompt Unit Tests"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - name: Run prompt module unit tests
        run: npx jest --testPathPattern='ai/(prompts|templates)/__tests__' --coverage
      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          flags: ai-prompts
 
  ai-regression-tests:
    name: "Layer 2: AI Regression Tests"
    runs-on: ubuntu-latest
    needs: prompt-unit-tests
    if: |
      (github.event_name == 'pull_request' && github.base_ref == 'main') ||
      github.event_name == 'schedule'
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - name: Run AI regression suite
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          # PRs use 25% sample; scheduled weekly runs use 100%
          AI_TEST_SAMPLING_RATE: ${{ github.event_name == 'schedule' && '1.0' || '0.25' }}
          AI_PASS_RATE_THRESHOLD: '80'
        run: npx ts-node scripts/runAIRegression.ts
        timeout-minutes: 15
      - name: Upload results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: ai-regression-results-${{ github.run_number }}
          path: test-results/ai/
          retention-days: 30

// src/ai/experiments/promptExperiment.ts
 
export interface PromptVariant {
  id: string;
  description: string;
  trafficPercent: number;   // Must sum to 100 across all variants
  buildPrompt: (input: unknown) => string;
  createdAt: string;
}
 
/**
 * Deterministic variant assignment based on user ID.
 * Same user always sees the same variant, regardless of when they request it.
 * This prevents the jarring experience of AI behavior changing mid-session.
 */
export function assignVariant(
  variants: PromptVariant[],
  userId: string,
): PromptVariant {
  // djb2 hash for deterministic, well-distributed bucketing
  const hash = userId.split('').reduce((acc, char) => {
    return ((acc << 5) + acc) + char.charCodeAt(0);
  }, 5381);
  
  const bucket = Math.abs(hash) % 100;
  let cumulative = 0;
  
  for (const variant of variants) {
    cumulative += variant.trafficPercent;
    if (bucket < cumulative) return variant;
  }
  
  // Fallback to last variant (handles floating point edge cases)
  return variants[variants.length - 1];
}
 
// Track both automated scores and behavioral outcomes
export interface ExperimentOutcome {
  variantId: string;
  userId: string;
  sessionId: string;
  judgeScore?: number;           // LLM-as-Judge score if evaluated
  userRating?: 1 | 2 | 3 | 4 | 5; // Explicit user rating if collected
  askedFollowUp: boolean;        // Did user ask another question?
  sessionDurationSeconds: number;
  converted: boolean;            // Did user take the desired action?
}
 
export function recordOutcome(outcome: ExperimentOutcome): void {
  // Send to your analytics provider
  // Posthog, Mixpanel, custom analytics — whatever your Rork app uses
  analytics.track('ai_experiment_outcome', {
    ...outcome,
    timestamp: Date.now(),
  });
}

// src/ai/monitoring/aiMetrics.ts
interface AIRequestMetrics {
  promptVersion: string;
  model: string;
  featureId: string;
  latencyMs: number;
  inputTokens: number;
  outputTokens: number;
  stopReason: string;
  wasFiltered: boolean;
  errorCode?: string;
  userId: string;
  sessionId: string;
}
 
export function recordAIRequest(metrics: AIRequestMetrics): void {
  // Structured event for your analytics pipeline
  analytics.track('ai_request', {
    ...metrics,
    timestamp: Date.now(),
    // Derived metrics for easier querying
    totalTokens: metrics.inputTokens + metrics.outputTokens,
    wasError: \!\!metrics.errorCode,
    wasTruncated: metrics.stopReason === 'max_tokens',
  });
}
 
// Wrapper that adds automatic instrumentation to any AI call
export async function instrumentedAICall<T>(
  params: {
    featureId: string;
    promptVersion: string;
    model: string;
    userId: string;
    sessionId: string;
  },
  callFn: () => Promise<{ response: T; inputTokens: number; outputTokens: number; stopReason: string }>
): Promise<T> {
  const startTime = Date.now();
 
  try {
    const result = await callFn();
    
    recordAIRequest({
      ...params,
      latencyMs: Date.now() - startTime,
      inputTokens: result.inputTokens,
      outputTokens: result.outputTokens,
      stopReason: result.stopReason,
      wasFiltered: false,
    });
 
    return result.response;
  } catch (error) {
    recordAIRequest({
      ...params,
      latencyMs: Date.now() - startTime,
      inputTokens: 0,
      outputTokens: 0,
      stopReason: 'error',
      wasFiltered: false,
      errorCode: error instanceof Error ? error.constructor.name : 'UnknownError',
    });
    throw error;
  }
}