my-saas-app/
├── app/            # App Router pages
│   ├── (auth)/
│   ├── (dashboard)/
│   └── api/
├── components/     # Shared UI components
│   ├── ui/          # Primitives (Button, Input)
│   └── features/    # Feature components
├── lib/             # Utilities, helpers
│   ├── auth.ts
│   ├── db.ts
│   └── stripe.ts
├── prisma/
│   └── schema.prisma
└── types/           # Shared TypeScript types

// ❌ Slow: O(n²) — AI caught this immediately
function findDuplicates(arr) {
  const dupes = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = i+1; j < arr.length; j++) {
      if (arr[i] === arr[j]) dupes.push(arr[i]);
    }
  }
  return dupes;
}

// ✅ Fast: O(n) — AI's optimized version
function findDuplicates(arr) {
  const seen = new Set();
  const dupes = new Set();
  for (const item of arr) {
    seen.has(item) ? dupes.add(item) : seen.add(item);
  }
  return [...dupes];
}

// AI Prompt: "Generate a typed Express router for
// a users resource with JWT auth middleware,
// input validation, and error handling"

import { Router } from 'express';
import { z } from 'zod';
import { requireAuth, validate } from '../middleware';
import * as userService from '../services/users';

const router = Router();

const UpdateSchema = z.object({
  name: z.string().min(1).max(100).optional(),
  email: z.string().email().optional(),
});

router.get('/', requireAuth, async (req, res, next) => {
  try {
    const users = await userService.list({ org: req.user.orgId });
    res.json({ data: users });
  } catch (err) { next(err); }
});

router.patch('/:id', requireAuth, validate(UpdateSchema),
  async (req, res, next) => {
    try {
      const user = await userService.update(req.params.id, req.body);
      res.json({ data: user });
    } catch (err) { next(err); }
  }
);

// AI generates complete test suite for this function
function parsePrice(input: string): number {
  const num = parseFloat(input.replace(/[^0-9.]/g, ''));
  if (isNaN(num)) throw new Error('Invalid price');
  return Math.round(num * 100) / 100;
}

// AI-generated tests ↓
describe('parsePrice', () => {
  it.each([
    ['$29.99', 29.99],
    ['€1,234.50', 1234.50],
    ['100', 100],
    ['0.001', 0],
    ['  $9.99  ', 9.99],
  ])('parses %s → %d', (input, expected) => {
    expect(parsePrice(input)).toBe(expected);
  });

  it.each(['', 'abc', 'N/A'])(
    'throws on invalid "%s"', (input) => {
      expect(() => parsePrice(input)).toThrow('Invalid price');
    }
  );
});

// AI Prompt: "Write a Playwright test for the
// checkout flow: add to cart, fill shipping,
// complete payment with Stripe test card"

import { test, expect } from '@playwright/test';

test('complete checkout flow', async ({ page }) => {
  await page.goto('/products');
  await page.getByTestId('product-card').first().click();
  await page.getByRole('button', { name: 'Add to Cart' }).click();
  await page.getByRole('link', { name: 'Checkout' }).click();

  await page.fill('[name="email"]', '[email protected]');
  await page.fill('[name="address"]', '123 Main St');

  // Fill Stripe test card in iframe
  const stripe = page.frameLocator('[name="stripe-card"]');
  await stripe.locator('[placeholder="Card number"]')
    .fill('4242 4242 4242 4242');

  await page.getByRole('button', { name: 'Pay Now' }).click();
  await expect(page).toHaveURL(/\/success/);
  await expect(page.getByText('Order confirmed')).toBeVisible();
});

# AI-generated: Full CI/CD pipeline
name: Deploy to Production

on:
  push:
    branches: [main]

jobs:
  test-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20', cache: 'npm' }

      - name: Install & Test
        run: |
          npm ci
          npm run lint
          npm run test:ci
          npm run build

      - name: Build Docker image
        run: |
          docker build \
            --build-arg VERSION=${{ github.sha }} \
            -t app:${{ github.sha }} .

      - name: Deploy to Railway
        uses: bervproject/railway-deploy@v1
        with:
          railway-token: ${{ secrets.RAILWAY_TOKEN }}

# AI Prompt: "Production Dockerfile for a
# Next.js 14 app — optimized for size,
# security (non-root), and build caching"

FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:20-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
# Security: non-root user
RUN addgroup -g 1001 appgroup && \
    adduser -u 1001 -G appgroup appuser
COPY --from=builder --chown=appuser /app/.next ./.next
COPY --from=deps /app/node_modules ./node_modules
USER appuser
EXPOSE 3000
CMD ["node", "server.js"]