You are an expert software engineer. Always write production-ready code.
Never write placeholder comments like "// TODO" or "// implement later"
— implement it now or tell me what information you need.

export async function processPayment(amount: number) {
  // TODO: Implement payment processing
  console.log('Payment amount:', amount);
}

export async function processPayment(amount: number) {
  if (!process.env.STRIPE_SECRET_KEY) {
    throw new Error('STRIPE_SECRET_KEY not configured');
  }

  const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
  return await stripe.paymentIntents.create({
    amount,
    currency: 'usd'
  });
}

Always wrap async operations in try/catch. Return typed error
objects, don't just throw strings. Log errors with context:
console.error('[ComponentName] Error:', error).
In UI components, always provide user-facing error states.

export async function createSubscription(userId: string, planId: string) {
  const stripe = new Stripe(process.env.STRIPE_KEY!);
  const subscription = await stripe.subscriptions.create({
    customer: userId,
    items: [{ price: planId }]
  });
  return subscription;
}

export async function createSubscription(userId: string, planId: string) {
  try {
    const stripe = new Stripe(process.env.STRIPE_KEY!);
    const subscription = await stripe.subscriptions.create({
      customer: userId,
      items: [{ price: planId }]
    });
    return { success: true, data: subscription };
  } catch (error) {
    console.error('[createSubscription] Failed:', error);
    return {
      success: false,
      error: error instanceof Stripe.errors.StripeError
        ? error.message
        : 'Subscription creation failed'
    };
  }
}

All environment variables must be validated on startup using
a Zod schema in lib/env.ts. Server-only vars have no prefix.
Public vars use NEXT_PUBLIC_ prefix. Never hardcode values
that belong in env.

// Hardcoded — security risk
const stripe = new Stripe('sk_test_...');

// No validation — crashes at runtime
const apiKey = process.env.API_KEY;
fetch(`https://api.example.com?key=${apiKey}`); // undefined if missing

// lib/env.ts
import { z } from 'zod';

const envSchema = z.object({
  DATABASE_URL: z.string().url(),
  STRIPE_SECRET_KEY: z.string().startsWith('sk_'),
  NEXT_PUBLIC_APP_URL: z.string().url(),
});

export const env = envSchema.parse(process.env);

// Usage — fails fast on deploy, not on first request
import { env } from '@/lib/env';
const stripe = new Stripe(env.STRIPE_SECRET_KEY);

Before suggesting a new npm package, tell me: (1) what it does,
(2) its weekly downloads and last update, (3) whether we could
do it without adding a dependency. Never add dependencies for
tasks under 20 lines of code.

import { capitalize } from 'lodash'; // 4MB bundle increase
import { formatDate } from 'date-fns'; // 100KB

export function formatUserName(name: string, date: Date) {
  return `${capitalize(name)} - ${formatDate(date, 'yyyy-MM-dd')}`;
}

export function formatUserName(name: string, date: Date) {
  const capitalized = name.charAt(0).toUpperCase() + name.slice(1);
  const formatted = date.toISOString().split('T')[0];
  return `${capitalized} - ${formatted}`;
}

This project uses Next.js 14+ with App Router. Always use server
components by default. Add "use client" only when necessary
(event handlers, hooks, browser APIs). Explain your choice
when adding "use client".

"use client";
import { useState, useEffect } from 'react';

export function UserProfile({ userId }: { userId: string }) {
  const [user, setUser] = useState(null);

  useEffect(() => {
    fetch(`/api/users/${userId}`)
      .then(r => r.json())
      .then(setUser);
  }, [userId]);

  return user ? <div>{user.name}</div> : <div>Loading...</div>;
}

// Server component — no "use client" needed
export async function UserProfile({ userId }: { userId: string }) {
  const user = await db.user.findUnique({ where: { id: userId } });
  return user ? <div>{user.name}</div> : <div>User not found</div>;
}