// Du schreibst:
interface User {
  id: string
  name: string
  email: string
}

// Copilot schlägt vor:
interface UserRepository {
  findById(id: string): Promise<User | null>
  findByEmail(email: string): Promise<User | null>
  create(user: Omit<User, 'id'>): Promise<User>
  update(id: string, data: Partial<User>): Promise<User>
  delete(id: string): Promise<void>
}

class UserRepositoryImpl implements UserRepository {
  // Copilot generiert die komplette Implementierung
  async findById(id: string) {
    return await prisma.user.findUnique({ where: { id } })
  }
  // ...
}

// Funktion:
function calculateDiscount(price: number, percentage: number): number {
  if (percentage < 0 || percentage > 100) {
    throw new Error('Invalid percentage')
  }
  return price * (1 - percentage / 100)
}

// Kommentar:
// Test cases for calculateDiscount

// Copilot generiert:
describe('calculateDiscount', () => {
  it('should calculate correct discount', () => {
    expect(calculateDiscount(100, 20)).toBe(80)
  })
  
  it('should throw error for negative percentage', () => {
    expect(() => calculateDiscount(100, -10)).toThrow('Invalid percentage')
  })
  
  it('should throw error for percentage over 100', () => {
    expect(() => calculateDiscount(100, 150)).toThrow('Invalid percentage')
  })
  
  it('should handle zero discount', () => {
    expect(calculateDiscount(100, 0)).toBe(100)
  })
})

// Funktion:
function processPayment(userId: string, amount: number, method: PaymentMethod) {
  // ... komplexe Logik
}

// Copilot generiert JSDoc:
/**
 * Processes a payment for a user
 * @param userId - The unique identifier of the user
 * @param amount - The payment amount in cents (e.g., 1999 for €19.99)
 * @param method - The payment method (card, paypal, sepa)
 * @returns Promise that resolves with payment confirmation
 * @throws {PaymentError} If payment processing fails
 * @throws {ValidationError} If amount is negative or zero
 * @example
 * await processPayment('user_123', 1999, 'card')
 */

Du: "Soll ich Monolith oder Microservices nutzen?"
Copilot: *schlägt beides vor*
Du: *musst trotzdem selbst entscheiden*

// Copilot kann das generieren:
function calculatePrice(product: Product): number {
  return product.basePrice * 1.19 // MwSt
}

// Aber nicht wissen:
// - Welche Produkte sind MwSt-befreit?
// - Gibt's Mengenrabatte?
// - Saisonale Preise?
// - B2B vs B2C Unterschiede?

// Copilot generiert oft:
const filtered = items.filter(x => x.active)
const mapped = filtered.map(x => x.name)
const sorted = mapped.sort()

// Besser:
const result = items
  .filter(x => x.active)
  .map(x => x.name)
  .sort()
// Eine Chain statt drei Arrays

Prompt: "Explain this code:

[... 200 Zeilen React Class Component aus 2017 ...]
"

ChatGPT:
"This is a React class component that manages a form state with 
validation. Here's what each part does:

1. componentDidMount: Fetches initial data
2. handleChange: Updates state with validation
3. handleSubmit: ...

In modern React, this would be rewritten as:
[... Functional Component mit Hooks ...]
"

Prompt: "Warum bekomme ich 'TypeError: Cannot read property map of undefined'?

[Code Snippet]
"

ChatGPT:
"The error occurs because 'items' is undefined when the component 
first renders. The API call in useEffect hasn't completed yet.

Fix:

{items?.map(item => ...)}  // Optional chaining

Or:

const [items, setItems] = useState([])  // Default to empty array
"

Prompt: "Review this React component for best practices:

[Component Code]
"

ChatGPT:
"Issues found:

1. ❌ Props not typed (add TypeScript interface)
2. ❌ useEffect missing dependency array
3. ❌ State updates not using functional form
4. ⚠️  Missing error handling for fetch
5. ⚠️  No loading state

Suggested improvements:
[Verbesserter Code]
"

Prompt: "This function is getting messy. How would you refactor it?

function processOrder(order) {
  // ... 150 Zeilen Chaos ...
}
"

ChatGPT:
"I'd suggest breaking this into smaller functions:

1. validateOrder(order)
2. calculateTotals(order)
3. applyDiscounts(order, totals)
4. processPayment(order, totals)
5. createInvoice(order, payment)

Refactored code:
[Sauberer Code mit Single Responsibility]
"

// ChatGPT schlägt vor:
import { useMagicHook } from 'react'

// Reality: Diese Hook existiert nicht

Du: "How do I use Next.js 15 App Router?"
ChatGPT: *erklärt Next.js 13 Ansatz*

Prompt: "Create a pricing table with 3 tiers. Include a popular badge 
on the middle tier. Make it responsive."

v0.dev generiert:
<PricingTable>
  <PricingTier>
    <h3>Starter</h3>
    <Price>€9/Monat</Price>
    <Features>...</Features>
  </PricingTier>
  {/* + CSS + Responsive Design */}
</PricingTable>

Du → ChatGPT → Copy/Paste Code → Anpassen → Testen

Du → Prompt in IDE → AI generiert Code direkt an richtiger Stelle

"Wo werden User-Permissions gecheckt?"
→ Cursor zeigt dir alle 23 Stellen

"Update all API calls to use the new auth header"
→ Cursor findet und updated alle Files

"Add TypeScript types to all React components"
→ Cursor updated 50 Files gleichzeitig

1. Problem identifizieren
2. Stack Overflow durchsuchen
3. Docs lesen
4. Code schreiben
5. Debuggen
6. Code-Review anfragen
7. Überarbeiten

1. Problem mit ChatGPT diskutieren
2. Copilot schreibt Boilerplate
3. Cursor hilft bei Multi-File Changes
4. AI macht ersten Code-Review
5. Mensch macht finalen Review

// ChatGPT suggestion:
eval(userInput)  // ❌ HUGE Security Risk!

// Developer kopiert's ohne nachzudenken
// Result: Remote Code Execution Vulnerability

Schlechter Prompt:
"make login"

Guter Prompt:
"Create a secure login form in Next.js with:
- Email and password validation
- Error handling
- CSRF protection
- Rate limiting
- TypeScript types
- Accessibility (ARIA labels)"

"make api"

"Create a RESTful API endpoint in Next.js App Router that:
- Accepts POST requests with JSON body
- Validates input using Zod
- Stores data in PostgreSQL using Prisma
- Returns proper HTTP status codes
- Includes error handling
- Uses TypeScript"

"Add rate limiting to this endpoint"
"Now add caching with Redis"
"Add comprehensive error messages"

"Review this code for:
- Security vulnerabilities
- Performance issues
- TypeScript best practices
- Accessibility"

"Explain the difference between useMemo and useCallback with examples"
"What are the trade-offs between SSR and SSG in Next.js?"

"Fix all TypeScript errors in the codebase"
→ AI macht's, erstellt PR, du reviewst nur

Du: *schreibst Function*
AI: "Should we add error handling here?"
Du: "Yes"
AI: *fügt try/catch hinzu*