Toni Granados' Site

New tool: `newest-files`

Fri, 28 Nov 2025 00:00:00 GMT

AI agents have gotten very good as of late and they've completely transformed how I work. There are still many things they don't do that well, but for certain things, they excel. One of those things they are great at is applying an existing pattern to a new thing.

This kind of task is easily accomplished by providing the example in the context for the LLM, but sometimes finding that example might be tricky, especially for big, old, established codebases in which there might be multiple ways of achieving the same thing, including old or deprecated code.

In big repos, the newest files often represent the most relevant patterns, conventions, and ideas. That’s exactly what an AI model should imitate.

To help with this, I've built newest-files, a simple CLI tool that prints the list of the newest files in a git repo. You can use a glob to filter the files and even see the commit and PR where they were introduced, to gather even more context on how they were built in the first place.

Agents can call this tool before generating code, pulling in real, relevant and up-to-date examples from your repo instead of relying on guesses. It helps them enhance their context on their own and do what they do best: context-aware copy-paste.

The tool is available in Homebrew, so you can install it by just running:

brew tap tngranados/newest-files
brew install newest-files

Or check out the GitHub repo.

I've also included some instructions explaining how to use the tool and its purpose that you can feed directly into your AI agent. Check them out here.

Here is an example using it in the Discourse repo:

$ newest-files 'app/jobs/**/*.rb'

Created          │ Author               │ File                                                       │ Commit
───────────────────────────────────────────────────────────────────────────────────────────────────────────────
2025-10-09 00:33 │ Natalie Tay          │ app/jobs/regular/process_localized_cooked.rb               │ 38e64200
2025-10-03 16:14 │ Ted Johansson        │ app/jobs/scheduled/notify_admins_of_problems.rb            │ 911502eb
2025-08-21 14:18 │ Ted Johansson        │ app/jobs/scheduled/clear_expired_impersonations.rb         │ b24a3d81
2025-08-20 12:55 │ Juan David Martínez… │ app/jobs/regular/site_setting_update_default_categories.rb │ 0d721b47
2025-08-20 12:55 │ Juan David Martínez… │ app/jobs/regular/site_setting_update_default_tags.rb       │ 0d721b47
2025-07-23 11:58 │ Blake Erickson       │ app/jobs/regular/check_video_conversion_status.rb          │ af3abb54
2025-07-23 11:58 │ Blake Erickson       │ app/jobs/regular/convert_video.rb                          │ af3abb54
2025-02-11 10:26 │ Bianca Nenciu        │ app/jobs/scheduled/calculate_scores.rb                     │ 87f88459
2025-02-11 10:26 │ Bianca Nenciu        │ app/jobs/scheduled/clean_up_bookmarks.rb                   │ 87f88459
2025-02-11 10:26 │ Bianca Nenciu        │ app/jobs/scheduled/clean_up_drafts.rb                      │ 87f88459

Showing 10 newest files matching 'app/jobs/**/*.rb'

In one glance, you get the newest patterns for jobs, super helpful when adding a new one or showing an AI agent how they should look today, not five years ago.

This is the first time I release a tool I built for myself to the public, but I've been using it for a while now with great success and thought it might be useful for others. Hopefully you find it useful too.

If you try it, I’d love feedback or ideas for improvements.

Pull Down Drawer in SwiftUI

Fri, 11 Aug 2023 00:00:00 GMT

I'm exploring how far can we go using SwiftUI to build components that follows the directives set by the great Designing Fluid Interfaces presentation from WWDC18 (if you haven't seen it, go ahead, it as relevant now as it was then).

My first experiment is this drawer or sheet that pulls down from the top.

<div class="flex justify-center"> <video autoplay loop muted playsinline poster="/videos/pull-down-drawer.webp"> <source src="/videos/pull-down-drawer.mp4" type="video/mp4" /> <source src="/videos/pull-down-drawer.webm" type="video/webm" /> Your browser does not support the video tag. </video> </div>

It's very simple, yet feels great to the touch.

The full view looks like this:

import SwiftUI

struct PullDownDrawer: View {
    // Define constants for different heights and the threshold for state change
    let closedHeight: CGFloat = 100
    let openHeight: CGFloat = 500
    let stateChangeThreshold = 0.3

    // Track the current height and the height when gesture is inactive
    @State private var currentHeight: CGFloat = 100
    @State private var idleHeight: CGFloat = 100

    // Calculate the normalized height (0 to 1)
    private var normalizedHeight: CGFloat { (currentHeight - closedHeight) / (openHeight - closedHeight) }
    private var isOpen: Bool { idleHeight == openHeight }

    // Track if the state change will occur during the gesture
    var wouldChangeState: Bool {
        // Dragging up when it's open
        (isOpen && normalizedHeight < 1 - stateChangeThreshold) ||
        // Dragging down when it's closed
        (!isOpen && normalizedHeight > stateChangeThreshold) ||
        // The drawer can also be closed when dragging past the maximum height, kinda like closing a blind
        (isOpen && normalizedHeight > 1 + stateChangeThreshold)
    }
    @State private var willChangeState = false

    // Define the drag gesture
    var gesture: some Gesture {
        DragGesture()
            .onChanged { value in
                let newHeight = idleHeight + value.translation.height

                if newHeight > openHeight {
                    // When dragging the drawer lower than the maximum height, simulate an increasing drag by reducing
                    // the extra height that we are applying with the drag
                    currentHeight = min(openHeight + pow(abs(newHeight - openHeight), 0.9), openHeight * 1.5)
                } else if newHeight < closedHeight {
                    // Similarly, increase drag when trying dragging below the minimum height
                    currentHeight = max(closedHeight - pow(abs(newHeight + closedHeight), 0.6), closedHeight / 1.65)
                } else {
                    currentHeight = newHeight
                }

                // Generate feedback when passing the state change threshold. The willChangeState flag is used to prevent
                // feedback from being generated multiple times.
                if wouldChangeState {
                    if !willChangeState {
                        UIImpactFeedbackGenerator(style: .light).impactOccurred()
                        willChangeState = true
                    }
                } else {
                    willChangeState = false
                }
            }
            .onEnded { value in
                // Using a bouncy animation, just change the height to the open or close height depending on the current
                // state and whether wouldChangeState is true. If changing state, we generate a heavier feedback that
                // feels great next to the lighter one used to indicate that the drawer were going to change state when
                // releasing the gesture, this one feels like a confirmation of the action
                withAnimation(.bouncy) {
                    if wouldChangeState {
                        currentHeight = isOpen ? closedHeight : openHeight
                        UIImpactFeedbackGenerator(style: .medium).impactOccurred()
                    } else {
                        currentHeight = isOpen ? openHeight : closedHeight
                    }

                    idleHeight = currentHeight
                }
            }
    }

    var body: some View {
        BackgroundView()
            .overlay(alignment: .top) {
                RoundedRectangle(cornerRadius: 18)
                    .fill(.ultraThinMaterial)
                    .ignoresSafeArea(edges: .top)
                    .frame(height: currentHeight)

                    .preferredColorScheme(.dark)
                    .gesture(gesture)
            }
    }
}

Everything is annotated in the code, but as a summary, what we are doing here is taking a DragGesture and use it's translation.height to update the height of the drawer, which is just a view overlayed over a the background view.

What makes it feels fluid and great to the touch is a combination of:

Being an interactive animation that you can control with your fingers
The haptic feedback that gives you an indication of what's happening
The spring animation

Overall, I'm a bit surprised how easy this was to make and I'm eager to keep exploring new interactions based on the Designing Fluid Interfaces presentation.

PS: The BackgroundView with the animated gradients used in this example is made using a Metal shader. Apple introduced a simpler way to use Metal shaders within SwiftUI. I'm exploring shaders right now as well and I might write a post about that in the future.

Testing SwiftUI's ViewModels

Mon, 26 Jun 2023 00:00:00 GMT

When it comes to testing ObservableObjects, we can leverage their capabilities to observe when a @Published property changes. This comes in handy during testing as we can suspend the test and wait until the property assumes the value we are expecting.

To do this, we use the Combine Publisher that @Published adds to the property. We subscribe to it and test whether the new values of the property satisfy a given condition. Once the condition is met, we can fulfill an Expectation that we had set previously.

I've written an extension to XCTestCase that introduces a couple of functions to simplify this process:

@MainActor
extension XCTestCase {
    func until<T>(
        _ publisher: T,
        satisfies conditions: [@Sendable (T.Output) -> Bool],
        timeout: TimeInterval = 1
    ) async where T: Publisher {
        let expectation = XCTestExpectation()
        var mutableConditions = conditions

        let cancellable = publisher.sink { _ in } receiveValue: { value in
            if mutableConditions.first?(value) ?? false {
                _ = mutableConditions.remove(at: 0)
                if mutableConditions.isEmpty {
                    expectation.fulfill()
                }
            }
        }

        await fulfillment(of: [expectation], timeout: timeout)
        cancellable.cancel()
    }

    func until<T>(
        _ publisher: T,
        satisfies condition: @escaping @Sendable (T.Output) -> Bool,
        timeout: TimeInterval = 1
    ) async where T: Publisher {
        await until(publisher, satisfies: [condition], timeout: timeout)
    }
}

To use them, you just need to make your test async and await the functions to finish:

    func testViewModel() async {
        let viewModel = ViewModel()

        let task = Task { await viewModel.addItem() }

        // Check that `isLoading` is updating
        await until(viewModel.$isLoading) { $0 == true}
        XCTAssertTrue(viewModel.isLoading)

        // Wait until task finishes and `isLoading` is back to false
        await task.value
        await until(viewModel.$isLoading) { $0 == false}

        XCTAssertEqual(viewModel.items.count, 1)
        XCTAssertFalse(viewModel.isLoading)
    }

For reference, this is the ViewModel:

class ViewModel: ObservableObject {
    @Published var items: [Int] = []
    @Published var isLoading: Bool = false

    func addItem() async {
        self.isLoading = true

        try! await Task.sleep(for: .seconds(1))

        self.items.append(self.items.count + 1)
        self.isLoading = false
    }
}

Using this techniques, you can easily and consistently test very common SwiftUI patterns. I hope you find them useful. Happy testing!

Keep your Mac awake when using Claude Code

Sun, 20 Jul 2025 00:00:00 GMT

It's been a while since I last posted here, but it's as good a time as any to pick this back up. Today, I want to share a handy tip for those of you using Claude Code.

Like most people in tech lately, I've been using and experimenting with LLMs and AI Agents. Cursor, Copilot, Cline, Roo Code… I've tried many things, but for the last few months, there's been one clear winner: Claude Code.

I first tried Claude Code shortly after it was released in February, but I didn't pay too much attention to it after I burned through $10 worth of tokens in 15 minutes. It did work pretty well, but at that cost, it just wasn't justifiable for my use. I came back a couple of months ago when Anthropic introduced Claude Max (and later Pro) plans that allow for flat fee usage.

I've been using it often since then. Although I'm not much of a vibecoder, it does help me with the blank page syndrome I often struggle with when starting a new project or a bigger feature in an existing one. Sometimes I even fully refactor Claude's output after using it, but I still find it worth prompting first.

Anyway, one of the main annoyances I've been dealing with is that when Claude works for a long time, my Mac may go to sleep and pause the agent. I often leave the agent running while I go make a coffee or get a snack, and it's very annoying to return to the computer only to find that it hasn't been doing anything in the meantime.

When Claude Code was updated with hooks support, I thought I could finally address this by just running caffeinate when it starts working and stopping it when it finishes. However, there was no hook for when it started working—until recently, that is. The UserPromptSubmit hook was added in version 1.0.54.

I've built these two scripts to be run as hooks that will prevent the Mac from sleeping only while Claude is running.

prevent_sleep.sh

#!/bin/bash

# Prevent Mac from sleeping while Claude Code is running (for upto 1 hour)
# Kill any previously running caffeinate process started by this script

if [ -f /tmp/claude_caffeinate.pid ]; then
    old_pid=$(cat /tmp/claude_caffeinate.pid)
    if ps -p "$old_pid" > /dev/null 2>&1; then
        # Ensure the process is caffeinate (full command line check)
        if ps -p "$old_pid" -o args= | grep -q '^caffeinate'; then
            kill "$old_pid" 2>/dev/null
        fi
    fi
    rm -f /tmp/claude_caffeinate.pid
fi

nohup caffeinate -i -t 3600 > /dev/null 2>&1 &
echo $! > /tmp/claude_caffeinate.pid

allow_sleep.sh

#!/bin/bash

# Re-enable Mac sleep by killing the caffeinate process and cleanup the PID file

if [ -f /tmp/claude_caffeinate.pid ]; then
    kill $(cat /tmp/claude_caffeinate.pid) 2>/dev/null
    rm /tmp/claude_caffeinate.pid
fi

And then added the hooks to .claude/settings.json

"hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/hooks/allow-sleep.sh"
          }
        ]
      }
    ],
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/hooks/prevent-sleep.sh"
          }
        ]
      }
    ]
  }

I've found this to work very well, hope you find it useful as well.