The annual Let’s Vision conference was held in Shanghai as scheduled, with this year’s theme being: “Born to Create, Powered by AI.” Therefore, alongside the regular sessions on Swift and spatial computing, the conference invited many developers to share their applications and insights regarding AI in their daily workflows. I benefited immensely from the speakers’ introductions to their AI workflows. The AI-themed venue, originally designed to hold only 300 people, was packed inside and out with an enthusiastic crowd.
However, among the many excellent sessions, a talk prepared by YuChe Cheng titled “Let’s Create 1-liner Code in Swift” drew my attention to another room. What exactly was this topic about? Driven by curiosity, I walked in. As a developer with a LeetCode rating of 2200+, YuChe Cheng demonstrated how to use the extensive higher-order functions provided by Foundation and Swift Algorithms to transform plain, ordinary for-loop code into elegant, beautiful, and highly Swift-styled function chaining (1-liner code). In doing so, he achieved a brilliant balance between readability and performance.
Watching the function chaining on the slides being elegantly iterated over and over again, I felt a refreshing sense of clarity and enlightenment. For the entire 30-minute talk, I remained in a state of pure excitement—a feeling that typically only emerges after I’ve racked my brain to finally conquer a difficult problem, or when I’ve deeply grasped a new concept.
Even though it was only a wall away from the main venue, the overwhelming popularity of the AI topic meant the audience for this talk was noticeably sparse. Rather than feeling regret that so many missed out on a fantastic presentation, my real concern is this: As AI penetrates further into our industry, will that distinctive “character” developers once pursued and imbued into their code—beyond mere functionality—fade into oblivion?
Developers shouldn’t only care about cold, compiled binaries. Code itself is a vessel for personal style. Just like writing an essay, beyond delivering logic and results, it carries aesthetic expression, reflecting the author’s personal taste and ingenuity.
At this year’s Let’s Vision, I felt as though we were standing at a crossroads: Should we relentlessly pursue the extreme efficiency brought by AI, or, while embracing change, can we ensure that the pride and craftsmanship belonging to developers are still preserved in the AI era?
Recent Recommendations
Swift 6.3 Released
Since Swift 6, the language has settled into a steady cadence of one minor release every six months. Swift 6.3 was released as expected last week. Compared to previous releases, this version does not introduce any major headline features, but instead focuses on refining the existing system: improvements in concurrency diagnostics, the introduction of the @c attribute to further strengthen C/C++ interoperability, and more granular control over compiler optimizations.
That said, this release still sends a clear signal: Swift is evolving from a language centered around Apple platforms into a more general-purpose language with cross-platform and system-level capabilities. The continued progress of Embedded Swift, Android support, and the unification of the SwiftPM build system all point in this direction. For most iOS developers, the short-term impact may feel limited, but in the long run, this is a foundational update paving the way for what comes next.
Designing a type-driven JSON in Swift
When API contracts are unstable and the understanding of fields between frontend and backend frequently drifts, Swift’s strong type system can actually amplify the friction at the JSON boundary. Roman Niekipielov introduces a deliberately minimal JSONValue type to handle such transitional data.
Compared to [String: Any], it preserves clearer type structure; compared to fully defined Codable models, it better accommodates frequently changing contracts. This approach does not aim to replace formal models, but rather to contain uncertainty at the boundary layer.
Swift Native AI Agent Development Series
While many developers build AI agents using Python or TypeScript, Chris Karani argues that Swift’s concurrency model is naturally well-suited for agent isolation and scheduling, with its strong type system and macro capabilities adding extra safety guarantees.
Across six articles, he explores this idea from multiple angles—from a unified multi-provider LLM SDK Conduit, to an agent runtime built on Apple Foundation Models Colony, and even Metal-accelerated context memory management. If you are considering building AI features on Apple platforms, this is one of the few comprehensive native approaches available today.
Talking Liquid Glass with Apple
Danny Bolella attended Apple’s Liquid Glass design workshop in New York, spending three days in close collaboration with design teams and SwiftUI engineers. The message from the event was clear: Liquid Glass is not a transitional experiment, but a long-term design direction that will become the default across future toolchains.
Apple also repeatedly emphasized the importance of hierarchy—interfaces should be built around content, with controls serving as supporting elements positioned toward the edges. Beyond that, Danny also shares practical advice and implementation insights from Apple engineers. The article offers an early look into the direction and philosophy behind this design evolution.
Apple Dropped 100+ New Metrics. Your Competitors Are Already Using Them
Apple has rolled out one of the most significant updates to App Store Connect in recent years, introducing 100+ first-party metrics, cohort analysis by source, peer benchmarks (conversion rate and revenue per download), and subscription data export via API. Jessica Chung provides a structured overview of these changes.
Since all data now comes directly from Apple, developers can move away from third-party estimates and make decisions based on real user behavior. More importantly, this update fills a long-standing gap: you can now track user quality across channels and keywords, build a full funnel from impression to subscription and retention, and benchmark your performance against peers.
This update is clearly beneficial for developers, but it also raises the bar for third-party App Store analytics tools, pushing them to deliver higher-value capabilities to remain competitive.
Package Traits in Xcode
When building an SPM package, some dependencies may only be used by specific APIs. However, once the package is added, those dependencies are included regardless of whether those APIs are used. Package Traits were introduced to address this issue by allowing developers to define optional features that consumers can enable as needed, avoiding unnecessary dependencies.
Unfortunately, after its introduction, this feature was only available in community Swift toolchains. With the release of Xcode 26.4, Package Traits finally gained official support from Apple, making broader adoption more likely. Matt Massicotte introduces the feature and demonstrates its usage in this article.
Why your SwiftUI app feels slow even though Instruments says it’s fine?
When users complain about slow responsiveness, is it always a performance issue? Rafał Dubiel shifts the focus from actual performance to perceived performance, exploring how UI feedback and interaction timing can make apps feel faster.
Techniques such as skeleton views, delayed loading, and thoughtful animations can effectively mask waiting time. The key insight is that user experience is often less about reducing milliseconds and more about providing timely feedback. Compared to raw performance optimization, this perspective has a more direct impact on how users perceive fluidity.
Adjusting line height in SwiftUI on iOS 26
iOS 26 introduces a new lineHeight(_:) modifier in SwiftUI for controlling the baseline distance between lines of text. Natalia Panferova provides a detailed comparison of its configurations, including presets (.loose, .tight), proportional scaling (.multiple(factor:)), incremental adjustments (.leading(increase:)), and absolute control (.exact(points:)).
Unlike lineSpacing(_:), which adjusts spacing between lines, lineHeight(_:) directly defines baseline distance, offering more consistent control. This addition further improves SwiftUI’s typography capabilities.
Natalia Panferova, a former member of Apple’s SwiftUI core team, has recently published a new book The SwiftUI Way, aimed at experienced SwiftUI developers. The book focuses on production patterns, common anti-patterns, and how to work with the framework rather than against it.
Tools
Cove: A Swift 6 Native macOS Open Source Database Client
Cove, developed by Emanuele Micheletti, is a native macOS database client built entirely with Swift 6. It currently supports a wide range of backends including PostgreSQL, MySQL, MariaDB, SQLite, MongoDB, Redis, ScyllaDB, Cassandra, and Elasticsearch. Built with SwiftUI and AppKit instead of Electron or web technologies, it delivers a lightweight experience aligned with macOS conventions.
What makes Cove particularly interesting is its architecture. All database capabilities are abstracted through a unified DatabaseBackend protocol, with no backend-specific logic in the UI layer. Whether dealing with SQL databases, key-value stores like Redis, or NoSQL systems like MongoDB and Elasticsearch, everything is normalized into a table model for rendering. Although still in an early v0.1.0 stage, it already supports querying, schema browsing, editing, SSH tunneling, and multi-tab workflows. Even if you don’t plan to use it as your daily database tool, it’s a valuable reference for Swift-based desktop app architecture.