Rork Max の SwiftUI ネイティブ生成能力を30機能で検証する — どこで迷わず任せられて、どこで人間が介入すべきか

// Rork Max が生成した REST API 連携コード（S評価の例）
// エラーハンドリング・async/await・Codable がすべて揃っている
 
struct Article: Codable, Identifiable {
    let id: Int
    let title: String
    let body: String
}
 
@MainActor
class ArticleViewModel: ObservableObject {
    @Published var articles: [Article] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
 
    func fetchArticles() async {
        isLoading = true
        errorMessage = nil
 
        do {
            guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts") else {
                errorMessage = "Invalid URL"
                isLoading = false
                return
            }
 
            let (data, response) = try await URLSession.shared.data(from: url)
 
            guard let httpResponse = response as? HTTPURLResponse,
                  (200...299).contains(httpResponse.statusCode) else {
                errorMessage = "Server error"
                isLoading = false
                return
            }
 
            articles = try JSONDecoder().decode([Article].self, from: data)
        } catch {
            errorMessage = error.localizedDescription
        }
 
        isLoading = false
    }
}

// A評価：StoreKit 2 の購入フロー（プロンプト3回で仕上げた版）
// ポイント：エラー種別の分岐とトランザクション検証を明示的に指定している
 
class SubscriptionManager: ObservableObject {
    @Published var isSubscribed = false
    private var updateListenerTask: Task<Void, Error>?
 
    init() {
        // トランザクション更新の監視を開始
        updateListenerTask = listenForTransactions()
        Task {
            await updateSubscriptionStatus()
        }
    }
 
    deinit {
        updateListenerTask?.cancel()
    }
 
    func purchase(product: Product) async throws -> StoreKit.Transaction? {
        let result = try await product.purchase()
 
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await updateSubscriptionStatus()
            await transaction.finish()
            return transaction
        case .userCancelled:
            return nil
        case .pending:
            // ファミリー購入承認待ちなど
            return nil
        @unknown default:
            return nil
        }
    }
 
    private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .unverified(_, let error):
            throw error
        case .verified(let safe):
            return safe
        }
    }
 
    @MainActor
    func updateSubscriptionStatus() async {
        for await result in StoreKit.Transaction.currentEntitlements {
            if case .verified(let transaction) = result {
                if transaction.revocationDate == nil {
                    isSubscribed = true
                    return
                }
            }
        }
        isSubscribed = false
    }
 
    private func listenForTransactions() -> Task<Void, Error> {
        // [weak self] を外すと Task がインスタンスを掴み続け、deinit が呼ばれません
        return Task.detached { [weak self] in
            for await result in StoreKit.Transaction.updates {
                guard let self else { return }
                if case .verified(let transaction) = result {
                    await self.updateSubscriptionStatus()
                    await transaction.finish()
                }
            }
        }
    }
}

// C評価の典型例：Rork Maxが生成しがちな「動かないARKit」コード
// これをそのまま使うと実機でクラッシュする
 
class BadARViewController: UIViewController {
    var arView = ARSCNView()  // ❌ フレームバインドをStoryboard前提で設定していない
 
    override func viewDidLoad() {
        super.viewDidLoad()
        view.addSubview(arView)  // ❌ オートレイアウトなし
        arView.session.run(ARWorldTrackingConfiguration())  // ❌ SessionDelegateなし
    }
}
 
// 実際に動作する最低限のARKit実装（人間が書き直した版）
class GoodARViewController: UIViewController, ARSCNViewDelegate, ARSessionDelegate {
    private lazy var arView: ARSCNView = {
        let view = ARSCNView(frame: .zero)
        view.translatesAutoresizingMaskIntoConstraints = false
        view.delegate = self
        view.session.delegate = self
        view.autoenablesDefaultLighting = true
        return view
    }()
 
    override func viewDidLoad() {
        super.viewDidLoad()
        view.addSubview(arView)
        NSLayoutConstraint.activate([
            arView.topAnchor.constraint(equalTo: view.topAnchor),
            arView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            arView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            arView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
        ])
    }
 
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        // 非対応端末で run すると、実機でだけ黙って何も映らなくなります
        guard ARWorldTrackingConfiguration.isSupported else {
            showUnsupportedDeviceAlert()
            return
        }
        let config = ARWorldTrackingConfiguration()
        config.planeDetection = [.horizontal, .vertical]
        if let format = ARWorldTrackingConfiguration.supportedVideoFormats.first {
            config.videoFormat = format
        }
        arView.session.run(config, options: [.resetTracking, .removeExistingAnchors])
    }
 
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        arView.session.pause()  // メモリリーク防止
    }
 
    func session(_ session: ARSession, didFailWithError error: Error) {
        if let arError = error as? ARError {
            switch arError.code {
            case .cameraUnauthorized:
                showCameraPermissionAlert()
            case .worldTrackingFailed:
                restartSession()
            default:
                print("AR error: \(arError.localizedDescription)")
            }
        }
    }
 
    private func showCameraPermissionAlert() {
        let alert = UIAlertController(
            title: "カメラへのアクセスが必要です",
            message: "設定アプリからカメラを許可してください",
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "設定を開く", style: .default) { _ in
            guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
            UIApplication.shared.open(url)
        })
        alert.addAction(UIAlertAction(title: "キャンセル", style: .cancel))
        present(alert, animated: true)
    }
 
    private func showUnsupportedDeviceAlert() {
        let alert = UIAlertController(
            title: "この端末では AR を利用できません",
            message: "AR 以外の機能はそのままお使いいただけます",
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        present(alert, animated: true)
    }
 
    private func restartSession() {
        arView.session.run(ARWorldTrackingConfiguration(),
                           options: [.resetTracking, .removeExistingAnchors])
    }
}

// 生成直後（C評価の典型）— body 内でモデルを毎回ロードしてしまう
struct BadClassifierView: View {
    @State private var label = ""
    var body: some View {
        VStack {
            Text(label)
            Button("分類") {
                // ❌ ボタンを押すたびにモデルを初期化している
                let model = try! MyImageClassifier(configuration: .init())
                // ❌ try! でクラッシュ経路をそのまま残している
            }
        }
    }
}

// 5回のプロンプトで到達したA品質のCore ML推論
enum ClassifierError: Error {
    case modelUnavailable
    case inferenceFailed
}
 
final class ImageClassifier {
    // Optional で持つと呼び出し側が失敗理由を受け取れないため、Result で保持します
    private static let instance = Result { try ImageClassifier() }
    static func shared() throws -> ImageClassifier { try instance.get() }
 
    private let model: VNCoreMLModel
 
    private init() throws {
        guard let coreMLModel = try? MyImageClassifier(configuration: MLModelConfiguration()) else {
            throw ClassifierError.modelUnavailable
        }
        self.model = try VNCoreMLModel(for: coreMLModel.model)
    }
 
    func classify(_ image: CGImage) async throws -> (label: String, confidence: Float) {
        try await withCheckedThrowingContinuation { continuation in
            var outcome: Result<(label: String, confidence: Float), Error> =
                .failure(ClassifierError.inferenceFailed)
 
            let request = VNCoreMLRequest(model: model) { request, error in
                if let error {
                    outcome = .failure(error)
                    return
                }
                guard let top = (request.results as? [VNClassificationObservation])?.first else {
                    return
                }
                outcome = .success((top.identifier, top.confidence))
            }
            request.imageCropAndScaleOption = .centerCrop
 
            do {
                // perform は同期実行で、完了ハンドラは return より前に呼ばれます。
                // だから resume はここに一度だけ置けば足ります。
                try VNImageRequestHandler(cgImage: image, options: [:]).perform([request])
                continuation.resume(with: outcome)
            } catch {
                continuation.resume(throwing: error)
            }
        }
    }
}

// 生成されがちなパターン（Warningが発生する）
class BadViewModel: ObservableObject {
    @Published var items: [String] = []
 
    func loadItems() async {
        // バックグラウンド処理後に items を更新するとWarning
        items = await fetchFromServer()
    }
}
 
// 正しいパターン
@MainActor
class GoodViewModel: ObservableObject {
    @Published var items: [String] = []
 
    func loadItems() async {
        items = await fetchFromServer()
    }
}