Master Swift ViewController Architecture

This is a UIKit ViewController skill covering lifecycle management, memory management, navigation, delegation, container view controllers, and modern data-source patterns for iOS apps. It centers on the correct lifecycle sequence and what belongs in each method:

class ExampleViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        // One-time setup, view bounds not yet set
        setupInitialConfiguration()
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        // Called every time before view appears
        refreshData()
    }
    
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        // View is now visible, start animations/timers
        startPeriodicUpdates()
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        // Pause operations, validate input
        pauseUpdates()
    }
    
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        // Stop expensive operations
        stopUpdates()
    }
}

It also covers weak-reference delegate and closure patterns to prevent retain cycles, programmatic push and present navigation with a dismiss helper that checks whether a navigation controller is present, safe-area-anchored Auto Layout constraints, and a custom container view controller pattern that manually manages addChild/willMove(toParent:)/didMove(toParent:) when swapping child view controllers.

Use this skill when building or reviewing UIKit view controllers that need correct lifecycle usage - data refresh belongs in viewWillAppear, not viewDidLoad - leak-free delegate and closure patterns, and either protocol-delegate or closure-based child-to-parent communication. It also covers modern UIKit features: UICollectionViewDiffableDataSource with snapshot-based updates, and state restoration via encodeRestorableState/decodeRestorableState. It is not a SwiftUI skill - every pattern here is UIKit-specific (view controller hierarchies, UINavigationController, manual constraint setup), so it isn't the right fit for a SwiftUI-based view layer.

Input is a screen's UI requirements and its place in the navigation hierarchy; output is a UIViewController subclass with lifecycle methods used correctly, memory-safe delegate and closure properties (weak var delegate, [weak self] capture lists), Auto Layout constraints anchored to safeAreaLayoutGuide, and, for list-based screens, a diffable data source that applies snapshots with animatingDifferences: true instead of manual reloadData() calls.

Built entirely on UIKit (UIViewController, UINavigationController, NSLayoutConstraint, UICollectionViewDiffableDataSource, NSDiffableDataSourceSnapshot) and Foundation's NSCoder for state restoration. Performance guidance rounds this out: lazy-load expensive UI components, keep heavy work off the main thread during view transitions, implement prepareForReuse() in custom table and collection view cells to reset state between reuses, and reach for loadViewIfNeeded() in test scenarios where a view needs to exist before assertions run.

iOS developers building or maintaining UIKit-based screens who want correct lifecycle usage, leak-free delegation, safe-area-aware layout, and modern diffable data sources applied consistently, rather than reasoning about view controller behavior from scratch per screen.