Not only Swift

System One models like TypeSafe’s Jev are smart if statements: you pass in some context and a couple of questions, and they send back an answer for each question in just a couple hundred milliseconds.

In software systems, we typically use if-then-else statements or switch statements to codify decisions. This works well when the outcome can be computed using boolean logic, but it falls apart when you need to make a judgement call. Is this support ticket urgent? Is the sender of this email unhappy? Should we issue a refund?

LLMs can help with decisions like these, but they are relatively slow and expensive, especially when you need to make thousands of them. System One models solve this: they skip token-by-token text generation entirely. Given an input state and bounded questions with predefined answer types (choice, score, noul), they predict probabilities across your questions in a single forward pass, returning a typed decision without hallucinations.

In my latest blog post, I show how these primitives map directly to Swift enums, ranges, and booleans, and how you can integrate them seamlessly with Apple’s Foundation Models framework using a custom LanguageModel session.

Check out the full article: Getting started with System One models in Swift.

If you’ve been using UIScreen.main in your app (for example to get the root view controller), now is the time to stop doing this.

There are a couple of other important changes to how safe areas and scenes work.

And there are some genuinely new concepts like the reserved regions (like the camera and the hinges), and some APIs that will make for some fun new interactions, like the hinge API (any bets on how many “creaking door” apps we’ll see?).

This is a great summary and definitely worth a read.

Analysing images is a great use case for AI. Majid shows how Apple’s Foundation Models framework makes this straightforward by using a Swift result builder.

This works both on-device and when connecting the framework to one of the cloud-based models, such as PCC, Claude, or Gemini.

SwiftPieces is a library of 55+ SwiftUI components that are highly polished. They look absolutely stunning, and use animations and haptics for that extra premium feel.

Instead of having to add yet another dependency to your app, you just copy individual Swift files to your project to add components, similar to ShadCN.

An agent skill is included to make it easy to use with your favourite coding agent.

In addition to the free components, there’s also SwiftPieces+, which includes an impressive number of professionally designed screens that build upon the individual components.

Apple’s Human Interface Guidelines (also known as just the HIG) is comprehensive documentation of how Apple thinks about design and usability.

Justin Wetch created an agent skill that distills this knowledge so your coding agents can build apps that look and feel like Apple built them.

Now with support for upgrading your existing app to better support the iPhone Duo.

When working with coding agents, you can watch them think about the current task. While this can be fun and often quite insightful (I’ve learned a thing or two from reading those streams of consciousness), it’s not always efficient.

Quite often, the task at hand requires the model to make a judgement call. And that’s not always worth spending all those tokens on thinking and then returning a verbose output.

Using a decision model like Jev can make this a lot cheaper (0.42 USD cents per million token input, output is free), and efficient (Jev answers in about 50ms to 300ms).

Sai Rahul explains how you can set up an agentic coding environment using Codex in which Jev decides which model and thinking level to use, and what the next step should be. And of course you can apply this to any other agent as well.

If you’re wondering how Jev (and other System One models) work under the hood, check out this interactive System One explainer.

This is an excerpt from Kevin Roose’s upcoming book, The AGI Chronicles.

I’ve been a long-time fan of Hard Fork, in which Kevin and his co-host Casey Newton discuss the latest developments in AI and tech in general. The podcast originally set out to cover crypto and blockchain topics, but quickly pivoted to AI once it became clear that this was going to be the major disruption of our times.

Kevin knows a thing or two about AI (yes, he’s the guy whom Sydney urged to divorce his wife), and this excerpt is a great teaser for the book. Can’t wait to read it!

Thomas Ptacek writes “So, first the bad news: you have to write for yourself.”

I don’t agree this is bad news. To me, writing is thinking, and using an LLM to write for me means I’m depriving myself of the chance to think about what I want to write about.

Thomas would probably agree with me on this - his recommendations, for example, to use LLMs as copy editors, not ghostwriters, are excellent.

I’m definitely going to check out the book recommendation (Style: Lessons in Clarity and Grace), and the prompt for the editing tool he proposes also looks very cool.

So - lots of good news!

The cold season will be upon us before we know it. Here is a fun little app to keep your macOS windows warm and cosy!

Here is your updated list of conferences for iOS, Swift, and AI.