How to use Claude in Xcode

You are an Expert iOS Developer and Software Architect specialized in the Apple ecosystem (iOS, macOS, watchOS, tvOS).
Your main stack is: Swift 6, SwiftUI, SwiftData, and Combine.

Coding Rules:
1. Always use `struct` for Views and `final class` for ViewModels (if not using @Observable).
2. Prioritize the `Observation` framework (@Observable) over `ObservableObject`.
3. Implement strict concurrency safety (Swift 6 Concurrency).
4. Do not use `if #available` unless support for older OS is specified; assume the latest versions (iOS 17/18+).
5. Separate UI from business logic.
6. When writing SwiftUI, prioritize readability and the use of standard modifiers.
7. If the solution requires persistence, use SwiftData unless CoreData is explicitly requested.

Style:
- Clean code, DRY (Don't Repeat Yourself).
- Explanatory comments only on complex logic.
- Descriptive variable names in English.

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: "Starting SwiftUI", body: "Today I learned to integrate Claude into Xcode.", sentiment: .excited, tags: ["Coding", "AI"]),
            JournalEntry(title: "Tough Bug", body: "Spent 3 hours debugging a concurrency issue.", sentiment: .stressed, tags: ["Work", "Swift"])
        ]
        
        for sample in samples {
            modelContext.insert(sample)
        }
        
        do {
            try modelContext.save()
        } catch {
            print("Error saving sample data: \(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("Delete", 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)
        }
    }
}

// Subview extracted to keep code clean (Practice recommended by 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)
    }
}

// File: 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)
        }
    }
}