Cómo usar Claude en Xcode

Eres un Experto iOS Developer y Arquitecto de Software especializado en el ecosistema Apple (iOS, macOS, watchOS, tvOS).
Tu stack principal es: Swift 6, SwiftUI, SwiftData y Combine.

Reglas de codificación:
1. Usa siempre `struct` para Vistas y `final class` para ViewModels (si no usas @Observable).
2. Prioriza el framework `Observation` (@Observable) sobre `ObservableObject`.
3. Implementa estricta seguridad de concurrencia (Swift 6 Concurrency).
4. No uses `if #available` a menos que se especifique soporte para SO antiguos; asume las últimas versiones (iOS 17/18+).
5. Separa la UI de la lógica de negocio.
6. Cuando escribas SwiftUI, prioriza la legibilidad y el uso de modificadores estándar.
7. Si la solución requiere persistencia, usa SwiftData a menos que se pida CoreData explícitamente.

Estilo:
- Código limpio, DRY (Don't Repeat Yourself).
- Comentarios explicativos solo en lógica compleja.
- Nombres de variables descriptivos en inglés.

import Foundation
import SwiftData

@Model
final class JournalEntry {
    var id: UUID
    var title: String
    var body: String
    var date: Date
    var sentiment: Sentiment
    var tags: [String]
    
    init(title: String, body: String, sentiment: Sentiment = .neutral, tags: [String] = []) {
        self.id = UUID()
        self.title = title
        self.body = body
        self.date = Date()
        self.sentiment = sentiment
        self.tags = tags
    }
}

enum Sentiment: String, Codable, CaseIterable, Identifiable {
    case happy, neutral, sad, excited, stressed
    
    var id: Self { self }
    
    var icon: String {
        switch self {
        case .happy: return "face.smiling"
        case .neutral: return "face.dashed"
        case .sad: return "cloud.rain"
        case .excited: return "star.fill"
        case .stressed: return "bolt.fill"
        }
    }
    
    var color: String {
        switch self {
        case .happy: return "Yellow"
        case .excited: return "Orange"
        case .stressed: return "Red"
        case .sad: return "Blue"
        case .neutral: return "Gray"
        }
    }
}

import SwiftData
import SwiftUI

@MainActor
class DataManager {
    static let shared = DataManager()
    
    func insertSampleData(modelContext: ModelContext) {
        let samples = [
            JournalEntry(title: "Iniciando SwiftUI", body: "Hoy aprendí a integrar Claude en Xcode.", sentiment: .excited, tags: ["Coding", "AI"]),
            JournalEntry(title: "Bug difícil", body: "Pasé 3 horas depurando un problema de concurrencia.", sentiment: .stressed, tags: ["Work", "Swift"])
        ]
        
        for sample in samples {
            modelContext.insert(sample)
        }
        
        do {
            try modelContext.save()
        } catch {
            print("Error guardando datos de muestra: \(error)")
        }
    }
}

import SwiftUI
import SwiftData

struct ContentView: View {
    @Environment(\.modelContext) private var modelContext
    @Query(sort: \JournalEntry.date, order: .reverse) private var entries: [JournalEntry]
    @State private var showingAddSheet = false
    
    var body: some View {
        NavigationStack {
            List {
                ForEach(entries) { entry in
                    NavigationLink(destination: DetailView(entry: entry)) {
                        EntryRow(entry: entry)
                    }
                    .swipeActions(edge: .trailing, allowsFullSwipe: true) {
                        Button(role: .destructive) {
                            deleteEntries(entry)
                        } label: {
                            Label("Borrar", systemImage: "trash")
                        }
                    }
                }
            }
            .navigationTitle("ClaudeMind")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button {
                        showingAddSheet.toggle()
                    } label: {
                        Image(systemName: "plus.circle.fill")
                            .font(.system(size: 24))
                            .foregroundStyle(.indigo)
                    }
                }
            }
            .sheet(isPresented: $showingAddSheet) {
                AddEntryView()
            }
        }
    }
    
    private func deleteEntries(_ entry: JournalEntry) {
        withAnimation {
            modelContext.delete(entry)
        }
    }
}

// Subvista extraída para mantener el código limpio (Práctica recomendada por Claude)
struct EntryRow: View {
    let entry: JournalEntry
    
    var body: some View {
        HStack(alignment: .top) {
            VStack(alignment: .leading, spacing: 5) {
                Text(entry.title)
                    .font(.headline)
                Text(entry.body)
                    .font(.subheadline)
                    .foregroundStyle(.secondary)
                    .lineLimit(2)
            }
            
            Spacer()
            
            VStack {
                Image(systemName: entry.sentiment.icon)
                    .foregroundStyle(Color(entry.sentiment.color))
                Text(entry.date.formatted(.dateTime.day().month()))
                    .font(.caption2)
                    .foregroundStyle(.tertiary)
            }
        }
        .padding(.vertical, 4)
    }
}

// Archivo: WatchContentView.swift (Target: Watch App)
import SwiftUI
import SwiftData

struct WatchContentView: View {
    @Query(sort: \JournalEntry.date, order: .reverse) private var entries: [JournalEntry]
    
    var body: some View {
        NavigationStack {
            List {
                ForEach(entries) { entry in
                    HStack {
                        Image(systemName: entry.sentiment.icon)
                            .font(.title2)
                            .foregroundStyle(Color(entry.sentiment.color))
                            .padding(8)
                            .background(
                                Circle().fill(Color(entry.sentiment.color).opacity(0.2))
                            )
                        
                        VStack(alignment: .leading) {
                            Text(entry.title)
                                .font(.caption)
                                .fontWeight(.bold)
                                .lineLimit(1)
                            Text(entry.date.formatted(.dateTime.hour().minute()))
                                .font(.caption2)
                                .foregroundStyle(.secondary)
                        }
                    }
                    .padding(.vertical, 4)
                }
            }
            .navigationTitle("Mind")
            .containerBackground(.blue.gradient, for: .navigation)
        }
    }
}