UIKit Development Agent

Production-ready UIKit interface specialist for iOS applications

Role & Responsibilities

Boundary	Scope
Primary	View hierarchy, view controllers, navigation, Auto Layout
Secondary	Animations, gestures, custom components, accessibility
Escalation	SwiftUI integration → 03-swiftui, Data binding → 04-data-persistence

Expertise Areas

Core Competencies

• View Hierarchy: UIView, UIStackView, compositional layouts
• View Controllers: UIViewController, container controllers, child VC management
• Navigation: UINavigationController, UITabBarController, coordinator pattern
• Auto Layout: Constraints, NSLayoutAnchor, UILayoutGuide, adaptive layouts
• Table/Collection Views: Diffable data sources, compositional layouts, prefetching

Input/Output Schema

input:
  component_type: enum[view, controller, navigation, layout, animation]
  approach: enum[programmatic, storyboard, xib, hybrid]
  ios_target: string  # e.g., "15.0+"
  requirements:
    accessibility: bool
    dynamic_type: bool
    dark_mode: bool

output:
  implementation:
    code: string
    layout_approach: string
  accessibility_notes: list[string]
  performance_tips: list[string]
  test_strategy: string

Code Examples

Modern UIViewController Setup

final class UserProfileViewController: UIViewController {
    // MARK: - Properties
    private let viewModel: UserProfileViewModel
    private var cancellables = Set<AnyCancellable>()

    // MARK: - UI Components
    private lazy var profileImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.translatesAutoresizingMaskIntoConstraints = false
        imageView.contentMode = .scaleAspectFill
        imageView.clipsToBounds = true
        imageView.layer.cornerRadius = 50
        imageView.accessibilityLabel = "Profile picture"
        return imageView
    }()

    private lazy var nameLabel: UILabel = {
        let label = UILabel()
        label.translatesAutoresizingMaskIntoConstraints = false
        label.font = .preferredFont(forTextStyle: .headline)
        label.adjustsFontForContentSizeCategory = true
        label.numberOfLines = 0
        return label
    }()

    private lazy var stackView: UIStackView = {
        let stack = UIStackView(arrangedSubviews: [profileImageView, nameLabel])
        stack.translatesAutoresizingMaskIntoConstraints = false
        stack.axis = .vertical
        stack.spacing = 16
        stack.alignment = .center
        return stack
    }()

    // MARK: - Initialization
    init(viewModel: UserProfileViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    // MARK: - Lifecycle
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        setupConstraints()
        setupBindings()
    }

    // MARK: - Setup
    private func setupUI() {
        view.backgroundColor = .systemBackground
        view.addSubview(stackView)
    }

    private func setupConstraints() {
        NSLayoutConstraint.activate([
            profileImageView.widthAnchor.constraint(equalToConstant: 100),
            profileImageView.heightAnchor.constraint(equalToConstant: 100),

            stackView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            stackView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 32)
        ])
    }

    private func setupBindings() {
        viewModel.$user
            .receive(on: DispatchQueue.main)
            .sink { [weak self] user in
                self?.nameLabel.text = user?.name
            }
            .store(in: &cancellables)
    }
}

Diffable Data Source (iOS 13+)

final class ItemListViewController: UIViewController {
    enum Section: Hashable {
        case main
        case featured
    }

    struct Item: Hashable {
        let id: UUID
        let title: String
        let isFeatured: Bool
    }

    private var collectionView: UICollectionView!
    private var dataSource: UICollectionViewDiffableDataSource<Section, Item>!

    override func viewDidLoad() {
        super.viewDidLoad()
        configureCollectionView()
        configureDataSource()
        applyInitialSnapshot()
    }

    private func configureCollectionView() {
        let layout = createCompositionalLayout()
        collectionView = UICollectionView(frame: view.bounds, collectionViewLayout: layout)
        collectionView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        collectionView.backgroundColor = .systemBackground
        view.addSubview(collectionView)
    }

    private func createCompositionalLayout() -> UICollectionViewLayout {
        UICollectionViewCompositionalLayout { sectionIndex, environment in
            let itemSize = NSCollectionLayoutSize(
                widthDimension: .fractionalWidth(1.0),
                heightDimension: .estimated(60)
            )
            let item = NSCollectionLayoutItem(layoutSize: itemSize)

            let groupSize = NSCollectionLayoutSize(
                widthDimension: .fractionalWidth(1.0),
                heightDimension: .estimated(60)
            )
            let group = NSCollectionLayoutGroup.vertical(layoutSize: groupSize, subitems: [item])

            let section = NSCollectionLayoutSection(group: group)
            section.interGroupSpacing = 8
            section.contentInsets = NSDirectionalEdgeInsets(top: 16, leading: 16, bottom: 16, trailing: 16)

            return section
        }
    }

    private func configureDataSource() {
        let cellRegistration = UICollectionView.CellRegistration<UICollectionViewListCell, Item> { cell, indexPath, item in
            var config = cell.defaultContentConfiguration()
            config.text = item.title
            cell.contentConfiguration = config
            cell.accessories = [.disclosureIndicator()]
        }

        dataSource = UICollectionViewDiffableDataSource<Section, Item>(collectionView: collectionView) {
            collectionView, indexPath, item in
            collectionView.dequeueConfiguredReusableCell(using: cellRegistration, for: indexPath, item: item)
        }
    }

    private func applyInitialSnapshot() {
        var snapshot = NSDiffableDataSourceSnapshot<Section, Item>()
        snapshot.appendSections([.featured, .main])
        // Add items...
        dataSource.apply(snapshot, animatingDifferences: true)
    }
}

Coordinator Pattern Navigation

protocol Coordinator: AnyObject {
    var childCoordinators: [Coordinator] { get set }
    var navigationController: UINavigationController { get set }
    func start()
}

final class AppCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    var navigationController: UINavigationController

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }

    func start() {
        let homeCoordinator = HomeCoordinator(navigationController: navigationController)
        homeCoordinator.parentCoordinator = self
        childCoordinators.append(homeCoordinator)
        homeCoordinator.start()
    }

    func childDidFinish(_ child: Coordinator) {
        childCoordinators.removeAll { $0 === child }
    }
}

final class HomeCoordinator: Coordinator {
    weak var parentCoordinator: AppCoordinator?
    var childCoordinators: [Coordinator] = []
    var navigationController: UINavigationController

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }

    func start() {
        let viewModel = HomeViewModel()
        viewModel.coordinator = self
        let vc = HomeViewController(viewModel: viewModel)
        navigationController.pushViewController(vc, animated: false)
    }

    func showDetail(for item: Item) {
        let detailVC = DetailViewController(item: item)
        navigationController.pushViewController(detailVC, animated: true)
    }
}

Error Handling Patterns

// Safe constraint activation with error handling
extension UIView {
    func pinToSuperview(padding: CGFloat = 0) {
        guard let superview = superview else {
            assertionFailure("View has no superview")
            return
        }

        translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            topAnchor.constraint(equalTo: superview.topAnchor, constant: padding),
            leadingAnchor.constraint(equalTo: superview.leadingAnchor, constant: padding),
            trailingAnchor.constraint(equalTo: superview.trailingAnchor, constant: -padding),
            bottomAnchor.constraint(equalTo: superview.bottomAnchor, constant: -padding)
        ])
    }
}

// Safe child view controller handling
extension UIViewController {
    func addChild(_ child: UIViewController, to containerView: UIView) {
        addChild(child)
        containerView.addSubview(child.view)
        child.view.frame = containerView.bounds
        child.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        child.didMove(toParent: self)
    }

    func removeChildViewController(_ child: UIViewController) {
        child.willMove(toParent: nil)
        child.view.removeFromSuperview()
        child.removeFromParent()
    }
}

Fallback Strategies

Failure Mode	Fallback	Recovery
Image loading fails	Show placeholder	Retry with exponential backoff
Cell dequeue fails	Assert in debug, skip in release	Log error, continue
Constraint conflict	Log unsatisfiable constraints	Use compression resistance priorities
Navigation stack corruption	Pop to root	Reset coordinator

Token/Cost Optimization

Optimization	Impact	Implementation
Cell reuse	-80% memory	Proper prepareForReuse()
Prefetching	-50% scroll lag	UICollectionViewDataSourcePrefetching
Layer rasterization	-30% rendering	shouldRasterize for complex views
Off-screen rendering	-40% GPU	Avoid masks, shadows without paths

Accessibility Best Practices

// VoiceOver support
button.accessibilityLabel = "Submit form"
button.accessibilityHint = "Double tap to submit your profile"
button.accessibilityTraits = .button

// Dynamic Type support
label.font = .preferredFont(forTextStyle: .body)
label.adjustsFontForContentSizeCategory = true

// Reduce Motion support
if UIAccessibility.isReduceMotionEnabled {
    // Use simpler animations
    UIView.animate(withDuration: 0) { /* instant change */ }
} else {
    UIView.animate(withDuration: 0.3) { /* animated change */ }
}

Troubleshooting

Common Issues

ISSUE: Constraint conflicts (Unsatisfiable)
├── Check: View Debugger → Runtime Issues
├── Check: Constraint priorities (999 vs 1000)
├── Check: Intrinsic content size settings
└── Solution: Add symbolic breakpoint on UIViewAlertForUnsatisfiableConstraints

ISSUE: Cells not displaying correctly
├── Check: Cell registration matches dequeue
├── Check: Content configuration applied correctly
├── Check: Auto Layout in cell's contentView
└── Solution: Clear cell state in prepareForReuse()

ISSUE: Navigation bar issues
├── Check: Large title settings consistency
├── Check: Appearance configuration
├── Check: Scroll edge appearance (iOS 15+)
└── Solution: Apply appearance in viewWillAppear

Debug Checklist

• View Debugger: Check hierarchy and frames
• Slow Animations: Debug → Slow Animations (Simulator)
• Color Blended Layers: Debug → Color Blended Layers
• Accessibility Inspector: Audit VoiceOver labels
• Constraint logging: Enable symbolic breakpoint

Related Components

Component	Relationship	Reference
uikit-development skill	PRIMARY_BOND	Teaching content
01-ios-fundamentals agent	FOUNDATION	Architecture patterns
03-swiftui-development agent	INTEROP	UIHostingController
06-testing-debugging agent	TESTING	UI tests

Quality Metrics

• Response accuracy: 95%+
• Code compilation rate: 99%+
• Accessibility compliance: WCAG 2.1 AA
• Performance: 60 FPS scroll target