When I learned to drive, I used a manual transmission (MT). At first, my lack of skill often left me flustered, so for my first car, I went straight for an automatic (AT). However, after driving for a few years, I began to crave that sense of total control, so I added a manual car to my collection. Regrettably, as traffic congestion grew worse, the joy of shifting gears was gradually canceled out by exhaustion, and that car eventually sat neglected. It has been nearly twenty years since I seriously drove a manual, but deep down, I still occasionally miss that time when “man and car were one.”
As AI integrates more deeply into my work and life, I feel my existence shifting from MT to AT. Undoubtedly, AI has helped me break through many bottlenecks and brought immense efficiency gains even in familiar fields. But strangely, my sense of wonder about it keeps fading. It seems to have saved me time, yet I haven’t gained the expected satisfaction from this “extra time.” Perhaps my threshold for expectations keeps rising, but the undeniable fact is: I haven’t experienced that simple joy in the process of learning and developing for quite a while.
Fortunately, I rediscovered this long-lost happiness a few days ago. While preparing my Keynote for iOS Conf SG, because the app still relies on relatively “primitive” construction methods for animation—and lacks AI features—I had a rare, uninterrupted block of time to manually experiment and tweak things. Even for a simple parallel animation, I tinkered with great delight, debating between transitions, standard animations, or “Magic Move.” Settings that an expert might finalize in two or three minutes took me half a day of tinkering. Although efficiency was non-existent, I enjoyed every moment. Looking at the final, slightly “crude” effect I’d built, I found myself genuinely moved by what I’d made.
For professionals, efficiency and completeness are certainly hard metrics. But being able to experience the tangible reality in the process is perhaps a fundamental human pursuit.
I probably won’t buy an MT vehicle again, but as long as I can still grip the steering wheel, I won’t let “smart driving” take over completely. The same goes for coding—I fell in love with it because it brought me pure joy. When all our tools push us to be faster and better, I think we should leave ourselves a bit of space to be slower and “dumber”—after all, an AT life isn’t necessarily better than an MT one.
Recent Recommendations
Farewell to Portable Assembly: I’ve Been Running Swift on MCUs for Seven Years
Since 2024, Swift has officially provided support for embedded systems, but gaining significant market share in this field still has a long way to go. In fact, as early as 2018, before the official support, Andy Liu and his MadMachine team began exploring and practicing the application of Swift in the embedded field, launching related hardware products along the way. They firmly believe that in increasingly complex development scenarios, Swift’s modern language features will demonstrate tremendous advantages. In this article, Andy shares his journey of exploration in this field over the past few years. I sincerely hope that Swift can showcase its charm in more scenarios.
Building a Base DialSlider Component in SwiftUI
In today’s world where AI capabilities are increasingly powerful, getting AI to help you implement a visual effect has become easier than ever. However, whenever I see developers continuously exploring implementation approaches and refining effects through their own “creative ingenuity”, I still find myself genuinely impressed. In this article recreating a “vintage telephone dial”, codelaby cleverly utilizes SwiftUI’s .compositingGroup() and .blendMode(.destinationOut) to achieve a dynamic “cutout” effect, making static numbers beneath the rotating layer clearly visible—offering more flexibility and native feel compared to simply rotating an image. Additionally, the article provides a thoroughly clear explanation of circular gesture handling, angle calculations (atan2), and stopper logic.
CKSyncEngine Questions and Answers
Many developers have complained about Core Data’s NSPersistentCloudKitContainer, finding it opaque and lacking customizability. However, when they actually try to tackle CloudKit data synchronization themselves, they discover there are far more considerations than imagined, with difficulty far exceeding expectations. Apple’s CKSyncEngine, introduced several years ago, completely broke through this impasse by providing clearer state management and error handling, automatically handling numerous complex edge cases, allowing developers to focus on building data synchronization logic.
Christian Selig shares his experience using the CKSyncEngine API through a Q&A format, detailing how CKSyncEngine serves as a perfect middle layer that retains data storage flexibility (you can continue using SQLite, Realm, or JSON) while taking over the most troublesome synchronization state management.
My Beef with the iOS 26 Tab Bar
SwiftUI’s adjustments to the Tab Bar in iOS 18 have had an impact almost comparable to when NavigationStack/NavigationSplitView replaced NavigationView—not only changing the design language but also having a disruptive effect on application implementation and data flow. The “search tab” feature introduced for iOS 26’s Liquid Glass style further advances this transformation. In this article, Ryan Ashcraft candidly points out numerous issues with the new Tab Bar design: the default floating style appears jarring in certain interfaces and is difficult to coordinate with the overall visual style of applications; new margin and spacing rules break long-standing design conventions, requiring developers to readjust large amounts of existing interfaces; more importantly, these changes have not significantly improved user experience but instead increased adaptation costs.
My biggest impression of the new Tab is that it will significantly impact developers’ decisions regarding minimum system versions when developing applications. Is it worth maintaining two sets of code for Tab? If simplifying implementation forces raising the minimum version to iOS 18, this might be another design intention of the SwiftUI team.
Dia: A Technical Deep Dive into The Browser Company’s macOS Browser
Arc was the first major Windows platform application built using Swift, and The Browser Company has made outstanding contributions to the Swift community’s Windows toolchain. After transitioning from Arc to Dia, the development team has not abandoned Swift, so what development frameworks does Dia specifically use on macOS?
In this article, Everett reveals Dia’s unique technical architecture: this is a native macOS application based on AppKit + SwiftUI, but its core rendering engine is not WebKit—instead, it embeds a self-modified Chromium (ArcCore). Additionally, a large number of local AI-related libraries (such as Apple MLX and LoRA adapters) were discovered in Dia’s binary files, indicating that Dia is not just about “speed” but has already prepared the underlying engineering for on-device AI inference.
Myths about Logitech Developer ID certificate expiration
A few days ago, many macOS users discovered that their Logitech mouse custom buttons had stopped working. Due to control console logs being filled with code signing-related errors, many users and media outlets attributed this to “Apple revoking certificates.” Through analyzing system logs, Jeff Johnson vindicated Apple’s role in this incident: this was not an Apple certificate service failure, but rather a software engineering issue on Logitech’s end. After updating, the Logi Options+ background process failed to pass macOS taskgated code signature validity verification and was directly terminated by the system. This article is not only a failure analysis report but also reminds developers: under macOS’s strict security mechanisms, the signature verification process for application updates cannot tolerate any carelessness.
“If your certificate expires, users can still download, install, and run versions of your Mac applications that were signed with this certificate. However, you’ll need a new certificate to sign updates and new applications.” — Apple Official Documentation
Stop Getting Average Code from Your LLM
Undeniably, in the ocean of information accumulated by humanity over time, high-quality data and information constitute only a minority. For individuals, we can purposefully identify and learn from this quality content. However, due to mechanism limitations, LLMs default to the “average” of their training data, causing the content they generate to appear mediocre in various aspects. In the specific context of Swift development, this often means generating large amounts of outdated, unstructured code.
To obtain high-quality code that conforms to Swift 6 standards or even specific architectural styles, the key is to combat this “regression to the mean” instinct. Krzysztof Zabłocki provides detailed guidance on how to use Few-Shot Prompting and context injection techniques, forcing the LLM to “forget” mediocre default settings by providing specific code examples and architectural specifications, instead generating high-quality code that precisely matches project standards.
Tools
swift-effect: A Type-Driven Approach to Side Effects
Alex Ozun has long focused on type-driven design in Swift, and this library is his practice of “Algebraic Effects + Effect Handlers” in Swift.
swift-effect doesn’t turn side effects into “data structures to be interpreted,” but rather models side effects as interceptable global operations (@Effect), combining and replacing behaviors at runtime through handlers, allowing business code to maintain a linear/procedural style while providing fine-grained control over I/O, concurrency, and other behaviors.
Core highlights:
- Maintains Linear Code: Calling effects like Console.print works like regular functions, but behavior can be dynamically determined by handlers.
- Behavior Testing Without Mocks: Use
withTestHandlerto intercept/assert effect sequences step by step, testing processes like “interactive scripts.” - Controllable Concurrency: Supports deterministic testing of Task/AsyncSequence, solving the problem of unstable concurrency ordering.
Codex Skill Manager: A macOS Tool for Multiple CLI Services
Many developers use multiple AI programming services simultaneously. Although they have similar concepts, configurations, and tool types, differences remain in specific settings and detailed descriptions, making it difficult for developers to manage all services uniformly. Thomas Ricouard’s Codex Skill Manager consolidates skills from Codex, Claude Code (as well as OpenCode and Copilot) in a single UI for viewing, searching, deleting, and importing, avoiding manual searching through multiple hidden directories.
Core Features:
- Local Skills: Scans paths like
~/.codex/skills/publicand~/.claude/skills, displaying lists and details - Detail Rendering: Markdown view + reference preview
- Remote Skills: Clawdhub search/latest lists, detail fetching and downloading
- Import/Delete/Custom Paths: Supports importing from zip or folders, sidebar deletion, adding custom paths
- Multi-platform Installation Status: Marks installation status for different platforms
Events
LET’S VISION 2026
Born to Create. Powered by AI.
-
Speakers • Exhibitors • Partners — now open
-
📍 Shanghai | March 27–29, 2026
Apple ecosystem · AI · Spatial Computing See you in Shanghai.
Let’s shape the future together.
Swift Student Challenge 2026
The annual student challenge returns once again. The challenge provides thousands of student developers with the opportunity to showcase their creativity and programming abilities, allowing them to present their work through App Playground and learn practical skills that will serve them throughout their careers.
This year’s submission period will be open from February 6 to February 28, 2026.