The modern iOS toolchain

iOS development has exactly one required tool and it only runs on a Mac: Xcode, Apple's free IDE (the app where you'll write, run, and debug your code). Everything — writing code, designing the UI, running the simulator, and uploading to the App Store — happens inside it.

The three names you'll hear constantly

• Xcode — the application you install. It bundles the editor, the iOS Simulator, the compiler, and the tools that sign and upload your app.
• Swift — the programming language. Modern, readable, and strongly typed, which means the compiler catches many mistakes before the app runs. This is a gift when you're pairing with AI: bad AI code often won't even compile.
• SwiftUI — Apple's framework for building interfaces. You describe what the screen should look like for a given state, and the framework figures out how to draw and update it. It's declarative, which happens to be exactly the style AI writes well.

A useful mental model: Swift is the language, SwiftUI is a library written in that language for making screens, and Xcode is the workshop where you assemble everything.

The shape of a SwiftUI screen

Here is a complete, working SwiftUI screen. You don't need to understand every token yet — just notice that it reads top-to-bottom like a description of the UI:

import SwiftUI

struct ContentView: View {
    // A piece of state. When it changes, the screen redraws itself.
    @State private var name = ""

    var body: some View {
        VStack(spacing: 16) {
            Text("Welcome to DayOne")
                .font(.largeTitle)
                .bold()

            TextField("Your name", text: $name)
                .textFieldStyle(.roundedBorder)

            if !name.isEmpty {
                Text("Hello, \(name)!")
                    .foregroundStyle(.secondary)
            }
        }
        .padding()
    }
}

VStack stacks its children vertically. @State marks a value the view owns; when name changes, SwiftUI re-runs body and updates only what differs. The $name passes a two-way binding so the text field can write back into your state. Roughly 80% of SwiftUI is combinations of these ideas — stacks, state, and bindings.