Introduction
Building iOS applications in 2026 is a craft that demands fluency across multiple frameworks: SwiftUI for declarative interfaces, UIKit for imperative control, Core Data for persistence, and Combine for reactive streams. Even experienced developers often waste hours on boilerplate or debugging subtle threading issues. This collection of 10 prompts is designed to be your structured reference — each prompt tackles a real-world scenario, provides a complete implementation, and explains the reasoning behind the code. You can copy-paste these prompts into your Xcode project or adapt them to your own architecture. All examples are based on official Apple documentation (SwiftUI 6, Swift 6, iOS 18) and follow current best practices.
1. SwiftUI: Dynamic List with Swipe Actions and Search
Task: Create a SwiftUI list that displays a dynamic array of items, supports swipe-to-delete and swipe-to-mark-as-favorite, and includes a search bar that filters results in real time.
Prompt:
import SwiftUI
struct ContentView: View {
@State private var items = ["Apple", "Banana", "Cherry", "Date", "Elderberry", "Fig"]
@State private var searchText = ""
@State private var favorites = Set<String>()
var filteredItems: [String] {
if searchText.isEmpty {
return items
} else {
return items.filter { $0.localizedCaseInsensitiveContains(searchText) }
}
}
var body: some View {
NavigationStack {
List {
ForEach(filteredItems, id: \.self) { item in
HStack {
Text(item)
Spacer()
if favorites.contains(item) {
Image(systemName: "star.fill")
.foregroundColor(.yellow)
}
}
.swipeActions(edge: .leading) {
Button {
if favorites.contains(item) {
favorites.remove(item)
} else {
favorites.insert(item)
}
} label: {
Label("Favorite", systemImage: "star")
}
.tint(.yellow)
}
.swipeActions(edge: .trailing) {
Button(role: .destructive) {
items.removeAll { $0 == item }
favorites.remove(item)
} label: {
Label("Delete", systemImage: "trash")
}
}
}
}
.searchable(text: $searchText, prompt: "Search fruits")
.navigationTitle("Fruits")
}
}
}
Example result: A scrollable list of six fruits. Swiping left on any row reveals a red delete button; swiping right reveals a yellow star button that toggles a star icon next to the item. Typing "ap" in the search bar instantly filters the list to show only "Apple". This pattern is directly reusable for task managers, contacts, or any collection that needs both editing and search.
Why it works: swipeActions are part of the List API since iOS 15, and searchable integrates seamlessly with NavigationStack. The @State properties trigger reactive updates, and the computed filteredItems keeps the logic clean and testable.
2. UIKit: Custom Collection View with Compositional Layout
Task: Build a UIKit collection view that displays items in a grid (2 columns) with a header that spans the full width, using UICollectionViewCompositionalLayout.
Prompt:
import UIKit
class GridViewController: UIViewController {
private var collectionView: UICollectionView!
private let data = Array(1...20).map { "Item \($0)" }
override func viewDidLoad() {
super.viewDidLoad()
configureCollectionView()
}
private func configureCollectionView() {
// Define item size: half the group width minus spacing
let itemSize = NSCollectionLayoutSize(
widthDimension: .fractionalWidth(0.5),
heightDimension: .fractionalHeight(1.0)
)
let item = NSCollectionLayoutItem(layoutSize: itemSize)
item.contentInsets = NSDirectionalEdgeInsets(top: 4, leading: 4, bottom: 4, trailing: 4)
// Group: two items side by side
let groupSize = NSCollectionLayoutSize(
widthDimension: .fractionalWidth(1.0),
heightDimension: .absolute(100)
)
let group = NSCollectionLayoutGroup.horizontal(layoutSize: groupSize, subitems: [item, item])
// Section with header
let headerSize = NSCollectionLayoutSize(
widthDimension: .fractionalWidth(1.0),
heightDimension: .absolute(50)
)
let header = NSCollectionLayoutBoundarySupplementaryItem(
layoutSize: headerSize,
elementKind: UICollectionView.elementKindSectionHeader,
alignment: .top
)
let section = NSCollectionLayoutSection(group: group)
section.boundarySupplementaryItems = [header]
let layout = UICollectionViewCompositionalLayout(section: section)
collectionView = UICollectionView(frame: view.bounds, collectionViewLayout: layout)
collectionView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
collectionView.backgroundColor = .systemBackground
collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: "cell")
collectionView.register(HeaderView.self, forSupplementaryViewOfKind: UICollectionView.elementKindSectionHeader, withReuseIdentifier: "header")
collectionView.dataSource = self
view.addSubview(collectionView)
}
}
extension GridViewController: UICollectionViewDataSource {
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return data.count
}
func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "cell", for: indexPath)
cell.contentConfiguration = UIHostingConfiguration {
VStack {
Text(data[indexPath.item])
.font(.body)
}
}
cell.backgroundColor = .secondarySystemBackground
cell.layer.cornerRadius = 8
return cell
}
func collectionView(_ collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, at indexPath: IndexPath) -> UICollectionReusableView {
let header = collectionView.dequeueReusableSupplementaryView(ofKind: kind, withReuseIdentifier: "header", for: indexPath) as! HeaderView
header.label.text = "My Grid"
return header
}
}
class HeaderView: UICollectionReusableView {
let label = UILabel()
override init(frame: CGRect) {
super.init(frame: frame)
label.translatesAutoresizingMaskIntoConstraints = false
addSubview(label)
NSLayoutConstraint.activate([
label.centerXAnchor.constraint(equalTo: centerXAnchor),
label.centerYAnchor.constraint(equalTo: centerYAnchor)
])
label.font = UIFont.preferredFont(forTextStyle: .headline)
}
required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
}
Example result: A full-screen grid of 20 items arranged in 2 columns, each cell is a rounded rectangle with gray background and the text "Item 1" etc. Above the grid is a header "My Grid" centered horizontally. The layout adjusts automatically to different screen sizes because it uses fractional widths.
Why it works: UICollectionViewCompositionalLayout is Apple’s recommended approach for complex layouts (WWDC 2019 session 215). It declaratively defines item, group, and section dimensions. The example also uses UIHostingConfiguration (iOS 16+) to embed SwiftUI views inside UIKit cells, bridging the two worlds.
3. Core Data: Saving and Fetching with Background Context
Task: Save a new Person entity (name, age) to Core Data and fetch all persons, ensuring both operations happen on a background queue to avoid blocking the main thread.
Prompt:
import CoreData
struct PersistenceController {
static let shared = PersistenceController()
let container: NSPersistentContainer
init(inMemory: Bool = false) {
container = NSPersistentContainer(name: "Model")
if inMemory {
container.persistentStoreDescriptions.first?.url = URL(fileURLWithPath: "/dev/null")
}
container.loadPersistentStores { _, error in
if let error = error as NSError? {
fatalError("Unresolved error \(error), \(error.userInfo)")
}
}
container.viewContext.automaticallyMergesChangesFromParent = true
}
func savePerson(name: String, age: Int16) async {
let context = container.newBackgroundContext()
context.undoManager = nil
await context.perform {
let person = Person(context: context)
person.name = name
person.age = age
do {
try context.save()
} catch {
print("Save failed: \(error)")
}
}
}
func fetchAllPersons() async -> [Person] {
let context = container.newBackgroundContext()
let request: NSFetchRequest<Person> = Person.fetchRequest()
request.sortDescriptors = [NSSortDescriptor(keyPath: \Person.name, ascending: true)]
return await context.perform {
do {
return try context.fetch(request)
} catch {
print("Fetch failed: \(error)")
return []
}
}
}
}
Example result: Calling await PersistenceController.shared.savePerson(name: "Alice", age: 30) saves a new Person to the persistent store without freezing the UI. Calling let persons = await PersistenceController.shared.fetchAllPersons() returns a sorted array of Person objects. The automaticallyMergesChangesFromParent = true ensures the main context sees changes from background saves.
Why it works: Core Data’s newBackgroundContext() creates a separate queue. Using context.perform (which is @Sendable) guarantees thread safety. This pattern is documented in Apple’s Core Data Programming Guide and is critical for apps that handle large datasets or frequent saves.
4. Combine: Debounced Search with Network Request
Task: Create a publisher pipeline that debounces text input from a text field by 300 milliseconds, then performs a network search and updates a list of results.
Prompt:
import Combine
import SwiftUI
class SearchViewModel: ObservableObject {
@Published var searchText = ""
@Published var results: [String] = []
private var cancellables = Set<AnyCancellable>()
init() {
$searchText
.debounce(for: .milliseconds(300), scheduler: RunLoop.main)
.removeDuplicates()
.filter { !$0.isEmpty }
.flatMap { query in
Future<[String], Never> { promise in
// Simulated network request
DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
let mockResults = ["Result for \(query) 1", "Result for \(query) 2"]
promise(.success(mockResults))
}
}
}
.receive(on: DispatchQueue.main)
.sink { [weak self] newResults in
self?.results = newResults
}
.store(in: &cancellables)
}
}
struct SearchView: View {
@StateObject private var viewModel = SearchViewModel()
var body: some View {
NavigationStack {
List(viewModel.results, id: \.self) { result in
Text(result)
}
.searchable(text: $viewModel.searchText)
.navigationTitle("Search")
}
}
}
Example result: As the user types in the search field, no request fires until they pause for 300ms. If they type "swift", the list updates to show "Result for swift 1" and "Result for swift 2" after an additional 500ms simulated delay. Duplicate queries (e.g., backspace and retype quickly) are ignored via removeDuplicates().
Why it works: debounce waits for a pause in input, reducing network calls. removeDuplicates prevents identical queries. flatMap switches to a new publisher for each query, automatically cancelling any in-flight request — this is a key advantage over switchToLatest when using Future.
5. SwiftUI: Custom Animations with Matched Geometry Effect
Task: Animate a view that transitions from a list cell into a full-screen detail view using matchedGeometryEffect, with a smooth scaling and position change.
Prompt:
import SwiftUI
struct Item: Identifiable {
let id = UUID()
let name: String
let color: Color
}
struct ContentView: View {
@State private var items = [
Item(name: "Red", color: .red),
Item(name: "Green", color: .green),
Item(name: "Blue", color: .blue)
]
@State private var selectedItem: Item?
@Namespace private var animation
var body: some View {
NavigationStack {
List(items) { item in
HStack {
RoundedRectangle(cornerRadius: 8)
.fill(item.color)
.frame(width: 40, height: 40)
.matchedGeometryEffect(id: item.id, in: animation)
Text(item.name)
}
.onTapGesture {
withAnimation(.spring(response: 0.6, dampingFraction: 0.8)) {
selectedItem = item
}
}
}
.navigationTitle("Items")
.overlay {
if let item = selectedItem {
Color.black.opacity(0.4)
.ignoresSafeArea()
.onTapGesture {
withAnimation(.spring(response: 0.6, dampingFraction: 0.8)) {
selectedItem = nil
}
}
RoundedRectangle(cornerRadius: 16)
.fill(item.color)
.frame(width: 200, height: 200)
.matchedGeometryEffect(id: item.id, in: animation)
.overlay(Text(item.name).foregroundColor(.white).font(.title))
}
}
}
}
}
Example result: Tapping the red row causes the small red square to smoothly scale up, move to the center, and become a large 200x200 square with a semi-transparent background overlay. Tapping the overlay reverses the animation. The transition feels fluid because the same geometry ID links the source and destination.
Why it works: matchedGeometryEffect tells SwiftUI that the small square and the large square are the same visual element. The Namespace ensures uniqueness. The spring animation provides natural motion. This technique is widely used in Apple’s own apps (e.g., Photos, App Store).
6. UIKit: Custom Transition Between View Controllers
Task: Implement a custom modal presentation where the presented view controller slides up from the bottom with a bounce effect, using UIViewControllerAnimatedTransitioning.
Prompt:
import UIKit
class BounceTransitionAnimator: NSObject, UIViewControllerAnimatedTransitioning {
func transitionDuration(using transitionContext: UIViewControllerContextTransitioning?) -> TimeInterval {
return 0.5
}
func animateTransition(using transitionContext: UIViewControllerContextTransitioning) {
guard let toView = transitionContext.view(forKey: .to) else { return }
let container = transitionContext.containerView
let finalFrame = transitionContext.finalFrame(for: transitionContext.viewController(forKey: .to)!)
// Start below the screen
toView.frame = finalFrame.offsetBy(dx: 0, dy: finalFrame.height)
container.addSubview(toView)
UIView.animate(
withDuration: transitionDuration(using: transitionContext),
delay: 0,
usingSpringWithDamping: 0.7,
initialSpringVelocity: 0.5,
options: .curveEaseInOut
) {
toView.frame = finalFrame
} completion: { finished in
transitionContext.completeTransition(finished)
}
}
}
class PresentingViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = .systemBackground
let button = UIButton(type: .system)
button.setTitle("Present", for: .normal)
button.addTarget(self, action: #selector(presentModal), for: .touchUpInside)
button.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(button)
NSLayoutConstraint.activate([
button.centerXAnchor.constraint(equalTo: view.centerXAnchor),
button.centerYAnchor.constraint(equalTo: view.centerYAnchor)
])
}
@objc func presentModal() {
let modal = UIViewController()
modal.view.backgroundColor = .systemYellow
modal.transitioningDelegate = self
modal.modalPresentationStyle = .custom
present(modal, animated: true)
}
}
extension PresentingViewController: UIViewControllerTransitioningDelegate {
func animationController(forPresented presented: UIViewController, presenting: UIViewController, source: UIViewController) -> UIViewControllerAnimatedTransitioning? {
return BounceTransitionAnimator()
}
}
Example result: Tapping the "Present" button causes a yellow view controller to slide up from the bottom of the screen with a noticeable bounce (damping 0.7). The transition takes 0.5 seconds and feels more natural than the default slide.
Why it works: UIViewControllerAnimatedTransitioning gives full control over the animation timeline. Using usingSpringWithDamping creates the bounce effect. Setting modalPresentationStyle = .custom is required for custom transitions to work.
7. Core Data: Batch Update Without Loading Objects
Task: Update the age field of all Person entities whose name starts with "A" to 40, without fetching them into memory — using NSBatchUpdateRequest.
Prompt:
import CoreData
func batchUpdateAges(to newAge: Int16, prefix: String) async {
let context = PersistenceController.shared.container.newBackgroundContext()
await context.perform {
let request = NSBatchUpdateRequest(entity: Person.entity())
request.predicate = NSPredicate(format: "name BEGINSWITH %@", prefix)
request.propertiesToUpdate = ["age": newAge]
request.resultType = .updatedObjectsCountResultType
do {
let result = try context.execute(request) as? NSBatchUpdateResult
let count = result?.result as? Int ?? 0
print("Updated \(count) persons")
// Refresh main context
DispatchQueue.main.async {
PersistenceController.shared.container.viewContext.refreshAllObjects()
}
} catch {
print("Batch update failed: \(error)")
}
}
}
// Usage: await batchUpdateAges(to: 40, prefix: "A")
Example result: All Person entities with names like "Alice" or "Andrew" have their age set to 40 without any fetch. The console prints "Updated 2 persons" (assuming two matching records). The main context is refreshed to reflect changes.
Why it works: NSBatchUpdateRequest operates directly on the persistent store, bypassing the context’s in-memory cache. It is much faster than fetching and saving each object individually, especially for large datasets. Apple recommends this approach for bulk updates in Core Data.
8. Combine: Merging Two Publishers into One Stream
Task: Combine a text field publisher and a toggle publisher into a single validation stream that emits true only when the text has at least 3 characters AND the toggle is on.
Prompt:
import Combine
class ValidationViewModel: ObservableObject {
@Published var username = ""
@Published var agreeToTerms = false
@Published var isValid = false
private var cancellables = Set<AnyCancellable>()
init() {
Publishers
.CombineLatest($username, $agreeToTerms)
.map { name, agreed in
name.count >= 3 && agreed
}
.assign(to: &$isValid)
}
}
struct RegistrationView: View {
@StateObject private var viewModel = ValidationViewModel()
var body: some View {
Form {
TextField("Username", text: $viewModel.username)
Toggle("Agree to terms", isOn: $viewModel.agreeToTerms)
Button("Submit") {
print("Submitted")
}
.disabled(!viewModel.isValid)
}
}
}
Example result: The Submit button remains disabled until the username has at least 3 characters and the toggle is switched on. As soon as both conditions are met, the button becomes active. The validation updates reactively with every keystroke or toggle change.
Why it works: CombineLatest emits a tuple of the latest values from both publishers whenever either changes. The map operator transforms the tuple into a boolean. assign(to:) (iOS 17+) automatically manages the subscription lifecycle. This pattern is the foundation of reactive form validation.
9. SwiftUI: Custom Shape with Animatable Data
Task: Create a custom Shape that draws a star with a variable number of points, and animate the change between 5 and 8 points.
Prompt:
import SwiftUI
struct StarShape: Shape {
var points: Int
var animatableData: Int {
get { points }
set { points = newValue }
}
func path(in rect: CGRect) -> Path {
var path = Path()
let center = CGPoint(x: rect.midX, y: rect.midY)
let outerRadius = min(rect.width, rect.height) / 2
let innerRadius = outerRadius * 0.4
let angleStep = (2 * .pi) / Double(points * 2)
var currentAngle = -Double.pi / 2
for i in 0..<points * 2 {
let radius = i.isMultiple(of: 2) ? outerRadius : innerRadius
let x = center.x + CGFloat(cos(currentAngle)) * radius
let y = center.y + CGFloat(sin(currentAngle)) * radius
if i == 0 {
path.move(to: CGPoint(x: x, y: y))
} else {
path.addLine(to: CGPoint(x: x, y: y))
}
currentAngle += angleStep
}
path.closeSubpath()
return path
}
}
struct ContentView: View {
@State private var starPoints = 5
var body: some View {
VStack {
StarShape(points: starPoints)
.fill(Color.yellow)
.frame(width: 200, height: 200)
.padding()
Button("Toggle Points") {
withAnimation(.easeInOut(duration: 1.0)) {
starPoints = starPoints == 5 ? 8 : 5
}
}
}
}
}
Example result: A yellow star with 5 points is displayed. Tapping the button triggers a one-second animation where the star smoothly morphs into an 8-pointed star (or back). The shape changes gradually because SwiftUI interpolates between the two path configurations.
Why it works: Conforming Shape to Animatable (via animatableData) allows SwiftUI to interpolate the points integer. Since the path generation uses the same formula for any number of points, the interpolation produces a smooth morph. This technique is documented in the "Animatable Shapes" section of Apple’s SwiftUI tutorials.
10. UIKit: Dynamic Type and Accessibility with Custom Fonts
Task: Configure a UILabel to use a custom font that scales with Dynamic Type, and support accessibility traits like adjustsFontForContentSizeCategory.
Prompt:
import UIKit
class DynamicTypeLabel: UILabel {
override init(frame: CGRect) {
super.init(frame: frame)
configure()
}
required init?(coder: NSCoder) {
super.init(coder: coder)
configure()
}
private func configure() {
// Register for Dynamic Type notifications
NotificationCenter.default.addObserver(
self,
selector: #selector(updateFont),
name: UIContentSizeCategory.didChangeNotification,
object: nil
)
// Set custom font with text style
let descriptor = UIFontDescriptor.preferredFontDescriptor(withTextStyle: .body)
let customDescriptor = descriptor.addingAttributes([
.family: "Helvetica Neue",
.traits: [UIFontDescriptor.TraitKey.weight: UIFont.Weight.medium]
])
font = UIFont(descriptor: customDescriptor, size: 0) // size 0 uses descriptor’s size
adjustsFontForContentSizeCategory = true
isAccessibilityElement = true
accessibilityTraits = .staticText
}
@objc private func updateFont() {
let descriptor = UIFontDescriptor.preferredFontDescriptor(withTextStyle: .body)
let customDescriptor = descriptor.addingAttributes([
.family: "Helvetica Neue",
.traits: [UIFontDescriptor.TraitKey.weight: UIFont.Weight.medium]
])
font = UIFont(descriptor: customDescriptor, size: 0)
}
}
// Usage in view controller:
let label = DynamicTypeLabel()
label.text = "Hello, World"
Example result: The label displays "Hello, World" in Helvetica Neue Medium at the body text size. When the user changes the Dynamic Type slider in Settings (e.g., to larger text), the label’s font size updates automatically. VoiceOver reads the text correctly because isAccessibilityElement is set.
Why it works: adjustsFontForContentSizeCategory tells UIKit to respond to Dynamic Type changes. The custom UIFontDescriptor preserves the text style’s scaling behavior while applying a custom family and weight. This approach is recommended by Apple’s Human Interface Guidelines for accessible apps.
Conclusion
These 10 prompts cover the most common tasks in modern iOS development: declarative UI with SwiftUI, imperative control with UIKit, data persistence with Core Data, and reactive streams with Combine. Each prompt is a complete, copy-pasteable solution that you can integrate into your own projects. The key takeaway is that Apple’s frameworks are designed to work together — for example, you can use Combine with SwiftUI, or embed SwiftUI views inside UIKit cells. By mastering these patterns, you’ll write cleaner, more maintainable code and reduce debugging time. Start by experimenting with one prompt that matches your current project’s need, then gradually adopt the others. Happy coding!
Comments