Leo Dion
CEO and Founder of BrightDigit
Lansing, Michigan, United States
Actions
Leo Dion is the founder of BrightDigit (https://brightdigit.com), a full-stack Swift development company he's been running since 2012.
He specializes in end-to-end Swift solutions—from iOS/macOS/watchOS to server-side Swift—and has shipped multiple App Store apps including Bushel (macOS virtualization for developers) and Heartwitch (Apple Watch health streaming). He's an active open source contributor with Swift packages including swift-build (popular GitHub Action for Swift CI/CD), MistKit (CloudKit REST API), SyntaxKit (code generation), DataThespian (SwiftData concurrency), PackageDSL, and SyndiKit (RSS parsing). Leo hosts EmpowerApps.show (https://empowerapps.show) and has been speaking about Swift since its launch.
He lives in Michigan with his wife Betsy and six kids. Watch his previous talks here: https://www.youtube.com/watch?v=WVXvIso24Sc&list=PLmpJxPaZbSnBTtrr4V6bksOfLVK4uK9q6
Area of Expertise
Topics
CloudKit as Your Backend: From iOS to Server-Side Swift
CloudKit has excellent documentation for iOS development. Backend services using the Web Services APIs? Far less known. Apple's server-side CloudKit docs leave critical gaps—authentication flows are scattered, type mapping is undocumented, and error handling examples barely scratch the surface.
This talk shares production patterns for using CloudKit from server-side Swift, drawn from building MistKit—a 10,476-line type-safe library supporting three authentication methods, nine HTTP status codes with typed error handling, and real deployment in backend command-line tools for data synchronization and content aggregation.
**Authentication That Actually Works:**
- API Token authentication for development and testing
- Web Auth Token for user-specific operations
- Server-to-Server authentication with key pairs for autonomous backend services
**Type Safety with Dynamic Fields:**
- CloudKit fields are dynamically typed; Swift is statically typed
- Solving polymorphism with `oneOf`, discriminated unions, and type overrides
- Making CKRecordValue (String, Int, Date, Asset, Reference, Location, or Array) safe at compile time
**Production Error Handling:**
- Nine HTTP status codes with nested error details require typed error hierarchies
- Retry logic for rate limits, conflict resolution for concurrent modifications, partial failure recovery in batch operations
**Ergonomic API Design:**
- Generated OpenAPI code is verbose and low-level
- Three-layer architecture: User API, abstraction layer, OpenAPI client
- Making CloudKit feel Swift-native from server-side code
Whether building data sync tools, RSS aggregators, or backend processing services, attendees leave with production-tested patterns for using CloudKit beyond typical iOS client-side usage—filling the documentation gaps that Apple's sparse backend references leave wide open.
How I learned to Vibe Code a SwiftSyntax DSL
SwiftSyntax is incredibly powerful, but it's also very challenging. The APIs are verbose, the compilation overhead is brutal, and most developers try to avoid it as much as they can.
That's why I decided to build SyntaxKit, a DSL that makes SwiftSyntax feel natural. To tackle this challenge, I used Cursor AI as my development partner.
This talk is two stories in one. First, I'll show you the technical magic behind SyntaxKit—how result builders and smart abstractions can turn SwiftSyntax from this massive verbose API into something that actually feels like Swift. You'll see exactly how to build type-safe DSLs that hide complexity without losing power.
But the other story is about coding with AI. Not the hype version where AI magically writes perfect code, but the messy reality where it's sometimes brilliant and sometimes completely wrong. I'll show you where Cursor saved me hours (avoid repetitive tasks) and where it led me down completely wrong paths (it loves outdated patterns).
AI can absolutely accelerate your work, but you need to know when to trust it and when to take the wheel. I'll give you the honest breakdown of what modern AI-assisted Swift development actually looks like.
Vibe Coding: Finding Your Rhythm Between AI and Human Expertise
This isn't about AI replacing developers—it's about finding the optimal rhythm between human expertise and AI assistance. From a starting point of deep skepticism, surviving every tech hype cycle (VR, Bitcoin, NFTs), to pragmatic production use—this talk shares an honest journey through AI-assisted Swift development.
The experiments tell the story: rebuilding a CloudKit library (10,476 lines) in 3 months using AI assistance, creating a code generation framework that reduces SwiftSyntax boilerplate from 100+ lines to 5, and discovering exactly where AI genuinely helps versus where it catastrophically fails.
**Where AI Genuinely Shines:**
- Boilerplate code generation (tests, documentation, repetitive patterns)
- Learning new frameworks through iterative exploration
- Translating between code patterns and architectural concepts
**Where AI Catastrophically Fails:**
- Swift 6 concurrency (outdated training data produces unsafe patterns)
- Post-WWDC APIs (training cutoff means AI doesn't know the latest Apple frameworks)
- Architectural decisions (over-engineering, scope creep, modifying unrelated code)
- Understanding specific codebase context and conventions
**The "70% Problem":**
AI gets you 70% of the way. Human expertise finishes the remaining 30%. Understanding this ratio determines whether AI becomes a productivity multiplier or a source of frustration and technical debt.
**Practical Tool Selection:**
Choosing between Cursor, Claude Code, and ChatGPT for specific Swift development tasks—with honest cost/benefit analysis for each.
**Career Navigation:**
Developers who understand AI will thrive—not be replaced. Building sustainable workflows means leveraging AI as a productivity multiplier while maintaining genuine expertise that AI cannot replicate.
Whether AI-curious, AI-skeptical, or AI-exhausted, attendees leave with honest navigation strategies for building sustainable development practices in uncertain times.
The Complete Automation Stack: Managing Swift Repositories from Testing to Distribution
In an age where AI can generate thousands of lines of Swift code in minutes, automated testing and CI/CD aren't optional—they're essential for catching issues that AI assistance might miss. Managing 128+ repositories reveals what works at scale and what breaks under pressure.
This talk shares the complete automation stack refined through years of production use: from project generation to multi-platform testing to automated TestFlight distribution—all triggered by a single commit.
**Project Generation:**
- Stop fighting with Xcode project files—use Tuist and XcodeGen to generate consistent projects for Swift packages and apps
- Manage project structure in version control, not opaque `.xcodeproj` files
**Multi-Platform Testing at Scale:**
- Building Swift packages that work across iOS, macOS, watchOS, tvOS, visionOS, Linux, Android, and WASM
- Going from 100+ lines of GitHub Actions config to just 5 lines with swift-build—achieving 65-85% build time improvements through intelligent caching
- Matrix testing across Swift versions and platforms with consistency across 100+ repositories
**AI-Powered CI:**
- Adding Claude Code and AI assistance to CI pipelines for automated updates and testing—while maintaining rigorous validation
- Automation validates AI-generated code at scale
**Fastlane Distribution:**
- Complete TestFlight automation—commit to distribution in 15 minutes
- Reducing manual uploads from 30-45 minutes to 2-3 minutes
Whether managing 1 repository or 100, attendees leave with proven automation strategies that start simple and scale as projects grow.
**Takeaway**: Automation isn't about saving time on one repo—it's about building systems that scale from side project to production infrastructure, validating code quality whether that code comes from humans, AI, or both.
Swift Argument Parser is Your Friend
The Swift Argument Parser is the premier way to build command line application. In the talk, Leo explains the basics of the Swift Package manager and how to get started building your first command line tool using the Swift Argument Parser. Leo also goes over decoding arguments, flags, and options and how to build a robust terminal application.
Generic Protocols and Associated Types - Power Tools for Unit Testing
What is an associated type? Why do we have generics? What’s the difference between any and some? In this talk get details on Swift’s type structure and how to have it work for you and not against you. Understand why Generics are the key to building more robust unit tests.
Full Stack Swift in the Real World
In this talk, Leo goes over the benefits and methods to building a full stack application in Swift from server to device. We talk about hosting setup, sharing code, networking, and more. If you are just curious about the process and technology involved, you’ll want to check this talk out.
Leo Dion
CEO and Founder of BrightDigit
Lansing, Michigan, United States
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top