SwiftUI-Agent-Skill

```swift
// Original Code Snippet (Flawed)
struct UserProfileView: View {
    @State private var user: User
    @State private var isLoading = false

    var body: some View {
        VStack {
            if isLoading {
                ProgressView()
            }
            Text(user.name)
            Text(user.bio)
            Button("Save") {
                Task {
                    isLoading = true
                    await saveUser()
                    isLoading = false
                }
            }
        }
    }

    private func saveUser() async {
        // Network call
    }
}

// Expert Review:

1. **State Management Issues**:
   - `user` should be `@StateObject` or `@ObservedObject` if owned externally, not `@State`. `@State` is for value types owned by the view. For reference types (e.g., `User` as a class), use `@StateObject` or `@ObservedObject` to ensure proper observation.
   - `isLoading` is correctly marked as `@State` (value type), but its usage is problematic. The `Task` closure captures `isLoading` weakly, which can lead to race conditions. Use `withAnimation` or `DispatchQueue.main.async` for state updates.

2. **Performance Bottleneck**:
   - The entire view re-renders when `isLoading` changes, even though only the `ProgressView` needs to update. Use `if` with a computed property or a separate `LoadingView` to isolate updates:
   ```swift
   var body: some View {
       VStack {
           if isLoading { ProgressView() }
           else {
               Text(user.name)
               Text(user.bio)
               Button("Save") { ... }
           }
       }
   }
   ```

3. **Modern SwiftUI Conventions**:
   - Replace `Task` with `.task(priority:)` modifier for async work tied to the view's lifecycle. This ensures cancellation when the view disappears:
   ```swift
   .task {
       isLoading = true
       await saveUser()
       isLoading = false
   }
   ```
   - Consider using `ObservableObject` for `User` to leverage `@Published` properties and Combine integration for reactive updates.

4. **Suggested Refactor**:
   ```swift
   class UserViewModel: ObservableObject {
       @Published var user: User
       @Published var isLoading = false

       func saveUser() async { ... }
   }

   struct UserProfileView: View {
       @StateObject private var viewModel = UserViewModel()

       var body: some View {
           VStack {
               if viewModel.isLoading {
                   ProgressView()
               } else {
                   Text(viewModel.user.name)
                   Text(viewModel.user.bio)
                   Button("Save") {
                       Task { await viewModel.saveUser() }
                   }
               }
           }
           .task { await viewModel.loadUser() }
       }
   }
   ```

Key Takeaway: Always prefer `@StateObject`/`@ObservedObject` for reference types, isolate state changes to minimize view updates, and use modern SwiftUI modifiers for async work.