I was studying the UX design of Apple Books and noticed that at the bottom of the Home screen, there is a reading goal progress dial, followed by your current streak, and your longest streak. You keep the streak alive if you spend enough time reading in the Apple Books app to meet your goal.

This streak design is not really a source of bragging rights, as there isn't much of a social element in Apple Books. There's no “my streak is longer than my frenemy's” badge of honor for readers to display.

At the same time, Duolingo's design has combined streaks with social to an extreme. You have your own streak. When you break your streak, your friend can save it for you by spending their own gems. When you pledge a streak of certain length and achieve the pledge, you get extra gems. You are also constantly nudged that your friend has achieved a crazy long streak. All this adds to the social pressure for the user to keep coming back to the game. (Duolingo has brought gamificaiton to another level. It's disrespectful if we don't call it a game.)

At the same time, Duolingo's design has combined streaks with social features to an extreme. You have your own streak. When you break your streak, your friend can save it for you by spending their own gems. When you pledge to maintain a streak of a certain length and fulfill the pledge, you get extra gems. You are also constantly reminded that your friend has achieved a remarkably long streak. All this adds to the social pressure on users to keep coming back to the game. (Duolingo has taken gamification to another level. It would be disrespectful not to call it a game.)

Now, what's interesting is that you only want to use the streak feature for activities that are traditionally considered boring or unengaging (reading, learning vocabulary).

If something is inherently engaging, you don't need a “streak” feature to remind users to come back. For example, you don't see a “streak” reminder splashed across TikTok's home screen.

I created a landing page for a project I've wanted to start for a long time. Much of the delay came from struggling to wrap my head around the project.

The best way to beat procrastination is to do something—anything, really—to get started. For me, that “something” was building a landing page.

I asked Codex to generate five landing-page mockups in vastly different styles. I then refined the design by asking it to develop variants of the two mockups I liked best.

Codex now (as of August 2026, with gpt-5.6-sol) understands images remarkably well. It can generate design mockups and accurately interpret their layouts.

After some discussion, I asked Codex to build the site with server-side rendering so that users receive fully rendered HTML without much JS fluff. I also wanted the landing page to include a waitlist feature.

This is my first time using Astro. Judging by the code Codex produced, Astro handles the job cleanly and elegantly.

What's remarkable is that Astro creates a server-side endpoint to receive signup requests without adding any bloat. The endpoint then inserts each email address into a database table.

Cloudflare makes this especially simple without any hassle. I deployed the landing page on Cloudflare Pages and connected it to a D1 database to store incoming waitlist signups. And it just worked.

I played with Swift over the weekend, and Xcode felt sluggish from time to time on my machine. I also had to ask Codex for help quite often just to navigate Xcode's UI.

When I tried coding with Zed, it failed to recognize structs, variables, and the like defined in other files in the project.

Quick googling led me to a very helpful blog post, “How I Got Zed Editor Working with Swift Projects,” and this GitHub repository: xcode-build-server.

Following the instructions in the blog post, I installed xcode-build-server, generated a buildServer.json file with the following command:

xcode-build-server config -scheme SCHEME_NAME -project PROJECT_NAME.xcodeproj

Zed could now recognize the project's symbols.

I wanted to use the simulator without opening Xcode. After some back and forth, I got hot reload working too. This is what I did:

• Navigate to the project directory and run open -a Simulator.
• Run xcodebuild to build the codebase as an .app bundle.
• Run xcrun to install and launch the built bundle in the simulator.

I've shared the Bash script I'm using in a GitHub Gist. Update values such as the project name, scheme, and directories, then install fswatch to watch for file changes. Now you can run this command and have fun:

open -a Simulator && dev.sh

I've been reading Life at the Speed of Play by Mark Pincus, founder of Zynga, the social gaming company behind Farmville.

Here are a few takeaways I found fascinating:

1. Instincts and ideas are two different things. Your instincts are almost always right. Your ideas are often wrong. Recognizing this distinction makes it much easier to abandon failing ideas without giving up the core insight. Your instinct tells you where the market is going or which problems are worth solving. Your ideas are a specific way to build a product or find a solution. Ideas tend to be wrong because they involve countless permutations of details. Which brings us to:
2. Proven, better, new. When you follow an instinct, find which features are proven to work in competing products and copy them. Identify which details in existing products you can objectively make better. Introducing new features or ways of interaction is risky. That's why:
3. A “minimum idea state” is much more useful than a “minimum viable product”. MVPs are too heavy. Instead, build out just enough of your idea to rapidly gather data and test the waters.

I was trying to stream market data from Alpaca's WebSocket endpoint.

Alpaca's documentation lists the following three steps to receive market data from the stream.

1. Connect to the endpoint.
2. Send an authentication frame.
3. Send a subscription frame.

Step 2 proved to be tricky.

The library I'm using is WebSockex. Per best practice, you should either send the auth frame in the handle_connect function or reply with an auth frame inside handle_frame when the “connected” message is received. In this particular case, both would fail or time out.

The handle_connect function is called immediately after the WebSocket connection is established. Inside handle_connect, you cannot return {:reply, auth_frame, state}. You can only return {:ok, state} or {:close, state}.

If you want to send the auth frame to the server, you'll have to use WebSockex.send_frame(pid, frame). ChatGPT keeps telling me to do the following, although it invariably causes a CallingSelfError. Apparently, you cannot just ask yourself (the same process) to send a frame.

1def handle_connect(_conn, state) do
2  # This will cause an error.
3  WebSockex.send_frame(self(), {:text, auth_frame})
4  {:ok, state}
5end

But in handle_frame function, you can return a tuple like this: {:reply, auth_frame, state}. The only thing you need to do is pattern match incoming frames. When you see "connected", return that reply tuple. This should have worked if it didn't time out. (Curiously, replying with a subscription frame worked.)

In the end, I did the following: I sent the auth frame inside the start_link function.

 1  def start_link(state) do
 2    connected = WebSockex.start_link(@uri, __MODULE__, state)
 3
 4    case connected do
 5      {:ok, pid} ->
 6        WebSockex.send_frame(pid, {:text, auth_json})
 7        {:ok, pid}
 8
 9      {:error, reason} ->
10        Logger.info(reason)
11    end
12  end

I finished reading  "Elixir in  Action." It's a great book that explains complex and novel (at least to me) ideas in simple and clear language.

In each  chapter, the author illustrates a set of new concepts with simple code examples and occasional exercises. As you go deeper  into the book, you'll clearly see how new concepts are built on top of the simpler concepts introduced earlier. It feels like recursion.

At its core, Elixir is very, very simple. You define small functions that perform specific tasks. You can specify the conditions under which these functions run using the when clause and pattern matching of parameters. You then build larger functions by iteratively composing smaller functions.

The notions of pure functions and immutability go hand in hand. They  may  seem  like  constraints on the  surface, until you  realize they have liberated you from asking  yourself,  "Am I manipulating this list in place or  not?" or  "Is this pointer mutable or  not?" No, you didn't change the list in place. No, it's not  mutable, and you don't need to worry about pointers.

The most basic way to coordinate processes is by sending messages.  A process quits when it has received and processed a message. To persist  a process, you recursively call the function that receives messages. There are complex features, but at the core are these simple notions. This makes it much easier to think about than  goroutines and  channels.

Go and read it.

1: Ask your coding agent to generate a minimal, runnable code snippet to demonstrate a concept.

2: After vibe-coding, ask your coding agent to summarize the changes it has made and create Anki flashcards.