Rizwan - iOS Developer

AI Agents - Close the loop for mobile apps

Sun, 18 Jan 2026 00:00:00 GMT

The Loop That Actually Ships

Most app flows are linear: a user does something, the app responds, and we stop. Agents break that line and turn it into a system that watches, decides, and tries again until the goal is met.

Diagram

Goal
↓
Sense → Decide → Act → Measure
↑ ↓
└─────────── Update ────┘

With the loop closed, you get:

Tasks that finish without constant prompts
Recovery paths when something fails
Behavior that adapts as the environment changes
Less manual babysitting

Mobile-Specific Challenges

Mobile is different. In web or backend work, you can simulate most behavior locally. On mobile, the real device matters. Cameras, sensors, thermal throttling, permissions, and OEM quirks are hard to fake. That makes the loop slower because humans end up doing the device-side validation.

Closing the loop on mobile means connecting the agent to real hardware and real state. For Android, that often looks like direct access to ADB so the agent can install builds, drive the UI, capture logs, and verify what actually happens on the device.

A Real Example

I was debugging a camera focus issue in an Android app. My old workflow was:

Ask a coding model for a fix.
Build in Android Studio.
Run on device.
Reproduce manually.
Repeat.

It worked, but it was slow and repetitive.

So I asked if the agent could verify its own changes. Once my device was connected over USB, it could run ADB commands to install builds, start the app, drive the camera flow, and capture outputs. I let it run for a couple of hours while it tried different hypotheses.

Hey, can you test this on the real device USB connected? Run whatever ADB commands you need, keep iterating until it works, and write every attempt plus screenshots into a md log file.

The result was a detailed markdown log of every experiment, complete with screenshots and what changed between attempts. I still had to steer it a few times, but it eventually found the root cause and taught me a lot about CameraX and Camera2 along the way.

Why This Matters

The compounding benefit is speed and rigor:

The agent can execute more experiments than I can in the same time.
Every attempt is logged, so the learning is reusable.
The loop closes on the real device, not just on a simulated environment.

That is what makes agents powerful for mobile: not just code generation, but autonomous testing and verification on actual hardware.

Blank SFSafariViewController

Mon, 08 Jun 2020 00:00:00 GMT

Recently We got continuous report from our clients saying they were getting blank In-App browser (SFSafariViewController) instead of the web page it was intended to show. After a little bit of debugging I figured out that It was actually bug from iOS side.

There is even a radar about it which you can find here. Looks like it was intentionally done by Apple. Here is the response from the radar

This is done to ensure SafariViewController can’t be used for loading content offscreen.

In our app, we don't actually load anything offscreen. There could be some delay to present the SFSafariViewController. These are the possible fix I found on the internet.

Make a delay before presenting the view controller
Load the view before in hand
Make the current window as key window

Adding delay is not user friendly so let's not look into that. Loading view before in hand works on some cases.

let controller = SFSafariViewController(url: url)
controller.delegate = self // load the view before in hand
present(controller, animated: true, completion: nil)

Other option would be make the current window as key window (only incase if you use multiple windows)

let window = << your current window >>
window.makeKey()
let controller = SFSafariViewController(url: url)
controller.delegate = self
present(controller, animated: true, completion: nil)

What actually works for my case is to present the SFSafariViewController from key window root view controller instead of some view controller in the view hierarchy.

 func openUrl(_ urlString: String, from viewController: UIViewController, completion: (() -> Swift.Void)? = nil) {
    guard let url = URL(string: urlString) else {
        showIncorrectUrlAlert(urlString, from: viewController)
        return
    }

    let vc = SFSafariViewController(url: url)
    vc.delegate = viewController as? SFSafariViewControllerDelegate
    // Present with window root view controller to avoid blank SFSafariViewController
    keyWindow?.rootViewController?.present(vc, animated: true, completion: nil)
}

My guess for this issue or fix would be disconnected view when you push safari view controller that causes window changes.

Cleanup for "Untitled" tvOS App

Wed, 05 Nov 2025 00:00:00 GMT

So far:

Cleanup

As I mentioned in my previous post, the initial MVP was okay with some quirks. My first goal was to get the app running reliably and worry about refinement later. To push it forward, I cycled through three tools and ran several sessions.

Claude Code with Sonnet 4.5 for planning and Haiku 4.5 for todos
Codex CLI with GPT Codex Medium
Amp in free mode

Amp had just released its free plan, and I wanted to try it that day. I had a perfect candidate, so I asked Amp CLI to fix issues one after another. When I wasn’t happy with the outputs, I moved to different agents.

I solved the following issues and learned a lot about how IPTV works in the background. Some of it felt not entirely above board, but it’s strictly for personal use.

Here are the main issues I worked through:

Made sure the API service was working by asking for a test file. Instead of running the app in the simulator every time, I wanted the agent to verify its own work.
Correctly wired the API service so every endpoint and tab view behaved.

By the end I had a somewhat working app where I could log in, see folders, browse live channels, and even play them with the default AVPlayer.

Satisfaction Level

But I wasn’t satisfied with the results. Here’s what I would have done better if I were building it myself:

The whole app had focus issues.
Weird focus states with white borders.
Card layouts looked rough.
Live streaming stopped after one minute.
Settings UI stretched awkwardly.
Search didn’t work.
Folder navigation felt clunky.

Even though the app technically ran, it still wasn’t usable. Up to this point I hadn’t reviewed the code much. I skimmed a few files, but because I’m still learning tvOS SwiftUI I assumed things were fine and accepted the changes.

When I ran the app on Apple TV, I wasn’t happy with the outcome. I wanted a polished experience, and instead I found more problems with back-button behavior. So I stepped away—motivation gone.

Hidden messages from Advent Of Code challenge

Sun, 22 Dec 2019 06:44:02 GMT

Incase if you don't know Advent Of Code is a small programming puzzles which can be solved in any programming language of your choice. It runs throughout the December and each day the complexity will increase.

This year the over all theme was about Santa on some other planet and how we help him to reach earth on time for Christmas. I started little late on Day 2 and tried to catch up all 4 puzzles.

Interesting thing I found today is one of the puzzle input was to figure out the input values to get output as 19690720.

If you look closely to the value it's actually a Date - 1960/07/20. Which is the exact date of Apollo Moon landing. 🤯 Also lots of keywords and things used on Apollo Guidance computer like Noun and Verb. Never expected hidden messages from the puzzle. Good Job for the Apollo nostalgia Eric Wastl

P.S: If you are following the advent calendar and wanted to check my solution in swift, you can check at this repo on Github. I will try to push it to GitHub whenever I found a solution.

Homework for "Untitled" tvOS App

Thu, 06 Nov 2025 00:00:00 GMT

So far:

Homework

The app wasn’t great. It was usable, but not even close to a four-star experience—more like a one-star prototype. I wanted to get it to at least four stars, so I did the one thing I hadn’t done yet: real homework, no LLMs involved.

I’ve been building for Apple platforms since the pre-ARC iOS 5 days, and I usually follow a personal checklist for new apps. This time I skipped it, and the results made that obvious. Time to catch up.

Inspirations

First, I needed to study real-world apps and how their UI behaves. I installed a bunch of IPTV apps on Apple TV and tested almost all of them. One stood out: UHF.

I might have used an LLM here—I asked Perplexity for IPTV app inspiration. Reddit pointed me toward a few options, and that’s how I found UHF.

I don’t know who built it, but it’s polished. The card layouts are great, everything feels snappy, and it has tons of features I hadn’t considered.

Mad respect to that developer—they shipped it pre-LLM.

tvOS 101

Next, I needed to understand how modern tvOS apps are built with SwiftUI. What does it take to achieve that level of polish? So I did what any Apple platform developer would do:

Read Apple’s Human Interface Guidelines for tvOS.
Watched relevant WWDC sessions.

Turns out tvOS didn’t get major features this year. I expected some SwiftUI updates—maybe liquid glass on tvOS 18—but the best resource I found was from tvOS 17: a session about migrating TVML-based apps to SwiftUI, complete with a sample project. I ran the sample and it worked perfectly on tvOS 18.

The session was WWDC24 session 10207: Migrate your TVML app to SwiftUI.

After watching the session and running the sample in the simulator, I had a much better sense of how tvOS and SwiftUI fit together. Now I knew what I needed.

What do you think I did next?

Introducing vector-triage

Sun, 15 Feb 2026 00:00:00 GMT

I just open-sourced vector-triage over the weekend:

GitHub: https://github.com/rizwankce/vector-triage

It runs as a GitHub Action and helps detect duplicates and similar items for Issues and PRs.

The idea started from a Twitter discussion when Pieter (@steipete) asked about this kind of feature in another OSS project. That project needed extra third-party dependencies for vector DB and embeddings. I wanted a simpler path for GitHub-native repos, so I built this around GitHub Models, which are free for minimal usage.

What vector-triage is for

vector-triage is a GitHub Action that:

embeds issue/PR content with GitHub Models
searches a local SQLite index (vector + FTS)
posts one managed triage comment when related items are found

It works for both Issues and Pull Requests.

Design goals

I kept the project focused on a few principles:

zero-config setup
deterministic behavior
low comment noise
safe defaults for OSS repos

Quick start

Setup is a single workflow file:

name: Triage

on:
  issues:
    types: [opened, edited]
  pull_request_target:
    types: [opened, synchronize]

permissions:
  contents: write
  issues: write
  pull-requests: write
  models: read

jobs:
  triage:
    runs-on: ubuntu-latest
    concurrency:
      group: triage-index
      cancel-in-progress: false
    steps:
      - uses: rizwankce/vector-triage@v1.0.2

That is the full setup.

How it behaves

First run: it creates the index and does not post noise comments.
Later runs: if matches exist, it posts or updates one managed triage comment.
If no matches are found, it stays quiet.
Recoverable failures are logged as warnings and exit non-fatally.

Built with Codex

I built most of this in a weekend with the help of Codex.

The biggest win was speed of iteration: shaping the retrieval behavior, comment format, and safety model quickly, then hardening with tests and E2E workflow checks.

Kotlin and Android Native

Fri, 05 Jun 2020 00:00:00 GMT

Long time iOS developer, but never actually tried anything in Android world. Though I Worked on the cross-platform stack and tried out Android Studio before but never tried to learn Android Native Development. Always I hear about Android X, app compatibility and Gradle build from my colleagues. Even I went into a rabbit hole of upgrading React Native version and stuck because It's breaking the whole project due to the need for AndroidX support.

30DaysOfKotlin

Last May, when everyone was under lockdown and I saw a tweet about #30DaysOfKotlin. It's an online Bootcamp program which teaches Kotlin and Android Native development with a series of Offical tutorials (called Codelabs) and webinar from Google. I registered immediately. Then days passed I never got the chance to go through the code labs but watched the first live stream webinar and which got me some interest about Kotlin because of the similarity between Swift and Kotlin. Then I went through the code labs for "Kotlin for Beginners" and "Android Kotlin fundamentals".

As part of the program, I had to develop something on Kotlin and submit before June 6th 2020. Since all the modern apps are pretty much JSON viewer with better UX. I decided to build an app which consumes some sort of REST web service and build a minimal but functional app in the given time.

DevCast

DevCast - A developer-focused podcast app which is using Offical APIs from dev.to. It has two screens, one to list the recent episodes and one for more details. The whole project itself open sourced and can be found here. Project is released under MIT License so you can do anything with it.

Here is the screenshots of the app. It has two screens, where first screen lists all the latest episodes from differnet podcast and second screen show the details of the selected episode.

These are some links where I learnt most about Kotlin and Android Native development. Incase if you would like to start your journey like me.

Google Codelabs

Others

Learning SwiftUI with NetNewsWire

Fri, 17 Jul 2020 00:00:00 GMT

After the release of SwiftUI 2.0 on WWDC 2020, I got excited and want to learn more about it. What is better than learning a new tech by building a real-world app? Here it goes my learnings...

NetNewsWire

I got the chance to learn SwiftUI from an open-source project called NetNewsWire. It's an RSS reader app for iOS, iPadOS and macOS. Build with UIKit/AppKit.

Shameless plug:- It's a cool app, you should check it out

After the WWDC, contributors to the project had a zoom call and decided to hop on the SwiftUI train. It's not new for the team. They have already burnt the hand by investing some time last year when the SwiftUI 1.0 was released. For various reasons the team had to stop and rollback everything done on SwiftUI. Since there are lots of improvements on 2.0, we have decided to try it to build the existing multi-platform app with the all-new SwiftUI multiplatform.

The whole team is ramping up with the latest cool beta things and I learnt a ton by implementing some small set of features on the Settings screen for iOS/iPadOS. One of my goals, when I started learning, is to share what I have learnt via blog posts. So I'm gonna kick start a set of blog posts which explains specific new features from SwiftUI 2.0.

The whole NetNewsWire community is great and I like to thank Brent Simmons for creating this project and making it open-source, Maurice Parker,Stuart for helping me and correct my direction whenever I lost in track, and all other contributors and users. If you would like to join, please check out our slack group. Everybody is welcome and encouraged to join.

MVP for "Untitled" tvOS App

Tue, 04 Nov 2025 00:00:00 GMT

So far:

Now, the actual MVP.

Phase 1

I was busy with other personal stuff and didn’t get a chance to work on the project. Around the same time, Claude launched Claude Code Web, so I spun up a new project session to try it out. I don’t know which model sits behind it, but my guess is Sonnet 4.5.

My first session prompt was simple:

i have milestones.md file.. please make sure that 1st milestone is complete or not. if not pls complete it

It finished quickly—Milestone 1 was just “Project Setup & Configuration.”

Then I spun up continuous sessions one after another. Each prompt followed the same pattern:

Please complete milestone 3 and 4 from milestones.md file

The whole time, I wasn’t even in front of my computer. I kicked off sessions from both the iOS app and Claude Web.

Afterward, I raised a PR for each session and merged them. It took roughly 30 minutes to complete 21 milestones. I didn’t review the code closely—everything came from Claude Web sessions—but I mainly needed the scaffolding in place so I could refine it later.

MVP

When I got back to my machine and pulled the latest changes, I was pleasantly surprised. All the files were there, and the project built just fine. I ran it on the tvOS simulator, and the login screen worked, aside from some focus quirks showing a weird white overlay. The app shipped with:

Tab view layout with four tabs
Login screen

Nothing worked after login, though. The app couldn’t fetch data from the server and threw errors—no live channel lists, no folders.

Network Activity logger for AFNetworking 3.0

Fri, 23 Dec 2016 00:00:00 GMT

Log all of your iOS project network activity to your console.

If you are an iOS developer (or Any mobile developer), you might be in a situation where you want to debug the network requests and responses for your app and figure out how exactly the app dealing with web services.

With the help of AFNetworkActivityLogger we can log all the details about the network operations to xCode console.

Incase if you are using swift and Alamofire, check out AlamofireNetworkActivityIndicator. Everything below is covered for Obj-C

Installation

Install Cocoapods if you don’t have already with the following command

gem install cocoapods

Note: CocoaPods version 0.39.0+ is required.

Podfile

To integrate AFNetworkActivityLogger into your xCode project using Cocoapods, specify it in your Podfile

source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '8.0'

target 'TargetName' do
pod 'AFNetworkActivityLogger'
end

Above pod file integration will take the latest version from Github repo. Unfortunately the latest version only works with AFNetworking v2.0. Incase if you want to use it for AFNetworking v3.0 edit the pod file as below.

pod ‘AFNetworkActivityLogger’, :git => ‘https://github.com/AFNetworking/AFNetworkActivityLogger.git', :branch => ‘3_0_0’

Above line will take the latest version from Git branch 3_0_0 which can be used with AFNetworking v3.0

Usage

AFNetworking 3.0

Add the following code to AppDelegate.m -application:didFinishLaunchingWithOptions::

[[AFNetworkActivityLogger sharedLogger] startLogging];

Ta-Da! now all your network activities will be logged in your Xcode console. By default log level is set as INFO, but incase if you want to see more logs follow the below lines.

AFNetworkActivityConsoleLogger *logger = [AFNetworkActivityLogger sharedLogger].loggers.anyObject;
logger.level = AFLoggerLevelDebug;
[[AFNetworkActivityLogger sharedLogger] startLogging];

Supported log levels are

AFLoggerLevelOff: Do not log requests or responses.
AFLoggerLevelDebug :Logs HTTP method, URL, header fields, & request body for requests, and status code, URL, header fields, response string, & elapsed time for responses.
AFLoggerLevelInfo: Logs HTTP method & URL for requests, and status code, URL, & elapsed time for responses.
AFLoggerLevelError: Logs HTTP method & URL for requests, and status code, URL, & elapsed time for responses, but only for failed requests.

AFNetworking 2.0

If you are using version 2.0 follow the below code.

[[AFNetworkActivityLogger sharedLogger] startLogging];
[[AFNetworkActivityLogger sharedLogger] setLevel:AFLoggerLevelError];

New Xcode Project - "Untitled" tvOS app

Sun, 02 Nov 2025 00:00:00 GMT

Just like many Apple platform developers, I finally did the thing and clicked:

Xcode → New Project

To be honest, this isn’t the first time I’ve done it—I have plenty of private GitHub repos to prove it. But this time feels different. I have access to the tools that let me get that first push out quickly and even ship most of the app while I’m eating breakfast, thanks to LLM agents.

I’ve been leaning on both CLI and cloud agents at work lately, so I wanted to try something new for a personal project.

The plan: build an app from scratch with LLM help. Not AI slop or vibe coding, but a human-in-the-loop setup where I decide what hits GitHub instead of blindly accepting every suggestion a model produces.

Idea

The idea sparked a while ago: a live IPTV app. I live outside my home country and rely on Apple TV all the time, so I’ve wanted a solid IPTV experience tailored for me.

I’ve never developed a tvOS app before, so this will be an experiment.

PS: I’m sharing this after spending about two weeks building the app on and off.

Tool Belt

Things are moving fast in the LLM world, so my tool belt keeps changing with it. So far I’ve used the tools below and I’ll share more in upcoming blog posts:

Claude Code
Codex CLI
Codex Web
Claude Code Web
Amp CLI

Plan for "Untitled" tvOS App

Mon, 03 Nov 2025 00:00:00 GMT

I have an idea and prepped some tools for it. Now it’s time for planning. After creating a blank Xcode project, setting up a GitHub repo, and pushing the first commit, I avoided jumping straight into coding or asking an LLM to “build me this app.” Instead, I spent time planning.

Planning

I used Claude Web with Sonnet 4.5.

I asked Claude to create a spec.md file with milestones and phases for my tvOS project. This is the exact prompt I used:

create a spec.md file for my personal app (not gonna release it to stores)

idea is to have tv OS app which deos followings.
* allow me to enter xstream code (username, password and url)
* fetch all the deatils and load into the UI (use swift ui and apple provided apis)
* when clicking the item from the list use apple provided api to stream content.

before creating the md file. ask me questions and then make it

I had to tell Claude that I’m not going to release it to stores because safety checks kicked in and refused to help with Xstream codes logins. Yes, I had misspelled a few things in the prompt.

After I answered some of Claude’s questions, it generated a spec.md file with two phases and lots of detail. Sharing just the phases here:

Phase 1 - Core Functionality (MVP)

 Authentication with credential storage
 Fetch and display Live TV channels
 Fetch and display Movies
 Fetch and display TV Series with episode navigation
 Search across all content
 Video playback with full controls
 Settings screen with account management
 Metadata display (when available)

Phase 2 - Enhanced Experience (Future)

 Categories/Genre filtering
 Favorites list
 Recently watched
 Continue watching
 EPG support for Live TV
 Multi-account support
 Parental controls (if needed later)

I copied this spec.md into my GitHub repo, created a new docs folder, and saved it there.

Milestones

Back on my machine, I opened the repo with spec.md and asked Claude Code with Sonnet 4.5 to create docs/milestones.md by reading docs/spec.md. After running for a bit, it produced 21 milestones for Phase 1 and 5 for Phase 2. It also added sections for “Suggested folder structure,” “Development Tips for LLM Implementation,” and “Common Pitfalls to Avoid.”

I really liked the plan and only edited a few parts. milestones.md is fairly long, so I’m sharing just one milestone here.

## Milestone 15: Settings Screen

**Objective:** Create settings/account management interface.

**File to Create:** `Views/Settings/SettingsView.swift`

**Implementation Requirements:**

1. **Server Information Section:**
   - Display server URL (read-only)
   - Display username (read-only)
   - Display connection status

2. **Account Management Section:**
   - "Change Account" button
   - Confirms action with alert
   - Clears credentials from Keychain
   - Returns to login screen

3. **App Information Section:**
   - App version number
   - About text

4. **Cache Management Section:**
   - "Clear Cache" button
   - Clears URLCache
   - Shows confirmation

**Success Criteria:**
- [x] Server info displays correctly
- [x] Change Account button works
- [x] Logout clears credentials
- [x] Returns to login after logout
- [x] App version displays
- [x] Clear cache works
- [x] Proper alert confirmations

Next comes my favorite part—building the actual app from spec.md and milestones.md. What do you think I did, and how do you think the first version turned out?

qmd for faster Obsidian search

Tue, 27 Jan 2026 00:00:00 GMT

I use Claude Code and Codex to search my Obsidian vault. The problem is those agents often load big markdown files into context and burn tokens. I keep a lot of notes in Obsidian, and the vault is now big enough that search started to feel slow. I wanted something fast, local, and still markdown-first.

I found qmd (Quick Markdown Search). It’s a CLI search engine for markdown files. It mixes classic full-text search (BM25), vector search, and LLM re-ranking, and it runs locally. That mix is exactly what I wanted: fast keyword search when I know the words, and semantic search when I don’t.

What I set up

I pointed qmd at my Obsidian vault and created a collection for it. Then I added a short context string so I can filter results later. After that I generated embeddings once, and now I just query.

Here’s the flow I’m using:

# install
bun install -g https://github.com/tobi/qmd

# add my Obsidian vault
qmd collection add ~/Obsidian/Vault --name obsidian
qmd context add qmd://obsidian "My Obsidian notes"

# build embeddings once
qmd embed

# fast keyword search
qmd search "work log okr"

# semantic search
qmd vsearch "what did i do on Jan first week?"

# best quality (hybrid + reranking)
qmd query "how I handle pagination in iOS app"

Why it feels faster

It’s a CLI, so I can keep my flow in the terminal.
Keyword search is instant for exact matches.
Semantic search gives me the file I meant even if I wrote different words.
Everything stays local, which is important for my notes.

How I use it with Obsidian

I still capture and edit in Obsidian. When I’m using Claude Code or Codex, I let the agent call qmd so it can search my vault fast without burning a bunch of context. For manual lookups, I jump to the terminal, run qmd, and then open the file in Obsidian.

If you have a big markdown vault, give qmd a try. It feels like a power-up for Obsidian.

Second Chance for "Untitled" tvOS App

Fri, 07 Nov 2025 00:00:00 GMT

So far:

Second Chance

After I created an MVP with LLM help, I wasn’t thrilled with the outcome. But now I had more knowledge about tvOS apps and a handful of solid inspirations.

So I asked Codex CLI to make the app better. I pasted the WWDC session link and the HIG link into the prompt and told it to go to town.

I wasn’t kidding—I was that literal. Turns out LLMs can’t browse Apple docs like we do. After a few rounds of trial and error, I found the reason and a workaround.

I discovered Sosumi, a handy tool that fetches Apple docs in an LLM-friendly format. I didn’t want to mess with an MCP server, so I dropped this note into my AGENTS.md/Claude.md file:

Apple Developer Documentation Tip
If the developer.apple.com documentation portal isn’t returning readable content from automated tooling, replace the host with sosumi.ai to get an AI-friendly copy:

Original: https://developer.apple.com/documentation/swift/array
AI-readable: https://sosumi.ai/documentation/swift/array

Now Codex could see what I see on Apple’s site. It fetched the docs and listed a set of improvements. I told it, “All clear, go ahead with the plan.”

Instead of fixing issues, it introduced more UI problems thanks to SwiftUI navigation quirks.

I tried the same request with Claude and Amp, but neither produced useful results.

So I restructured part of the app myself. I edited code in Xcode like it was the pre-LLM era—copying patterns from Apple’s sample project—and built a better card layout and navigation stack.

For once, I was happy with the result. Then I asked Codex to mirror the first tab’s structure across the remaining tabs and navigation flows. The UI finally felt decent: fewer focus glitches, better navigation.

I’d rate it 2.5 stars at that point.

But the default AVPlayer still didn’t work. After lots of conversations with ChatGPT, I learned it wasn’t an easy fix. My inspiration app had a setting to switch players and suggested VLC or KSPlayer.

So I asked Codex CLI to create a new VideoPlayerView based on VLC’s sample project. It one-shotted the feature, and I fixed the media streaming issue on top of that.

The app finally bumped up to a solid three stars.

Secure API Key Management with 1Password CLI

Thu, 14 Aug 2025 00:00:00 GMT

We've all been there - storing API keys directly in our .zshrc, .bashrc, or .bash_profile files for easy access. While convenient, this approach has serious security implications. Your API keys are stored in plaintext, visible to anyone with access to your shell configuration, and at risk of being accidentally committed to version control.

The Problem with Plaintext Storage

The traditional approach looks like this in your .zshrc:

export GEMINI_API_KEY="your-secret-api-key-here"
export OPENAI_API_KEY="another-secret-key"
export AWS_ACCESS_KEY_ID="yet-another-key"

This creates several security risks:

Plaintext exposure: Keys are readable by any process or user with access to your shell files
Version control leaks: Easy to accidentally commit these files with sensitive data
System-wide access: Any application can read these environment variables
No audit trail: No way to track when or how these keys are accessed

Enter 1Password CLI

1Password CLI (op) provides a secure way to store and retrieve sensitive information like API keys. Instead of storing keys in plaintext, we can store them securely in 1Password and retrieve them dynamically when needed.

Setup

First, install the 1Password CLI if you haven't already:

# macOS with Homebrew
brew install --cask 1password-cli

# Or download from https://1password.com/downloads/command-line/

Next, authenticate with your 1Password account:

op account add
op signin

Storing API Keys in 1Password

Create a new item in 1Password for your API key. You can do this through the 1Password app or CLI:

# Create a new item with your API key
op item create --category="API Credential" \
  --title="Gemini CLI" \
  --field="password=your-actual-api-key-here"

Dynamic Key Retrieval

Now, instead of hardcoding the key in your .zshrc, use the 1Password CLI to retrieve it dynamically:

# In your .zshrc file
export GEMINI_API_KEY=$(op item get 'Gemini CLI' --fields password --reveal)

The --reveal flag ensures that the password field is displayed in plaintext for use as an environment variable.

Complete Shell Configuration

Here's how your .zshrc might look with multiple API keys managed securely:

# Secure API key management with 1Password CLI
export GEMINI_API_KEY=$(op item get 'Gemini CLI' --fields password --reveal)
export OPENAI_API_KEY=$(op item get 'OpenAI API' --fields password --reveal)
export AWS_ACCESS_KEY_ID=$(op item get 'AWS Credentials' --fields username --reveal)
export AWS_SECRET_ACCESS_KEY=$(op item get 'AWS Credentials' --fields password --reveal)

Benefits

This approach provides several advantages:

Encrypted storage: Keys are stored encrypted in 1Password's secure vault
Audit trail: 1Password tracks access to your items
Centralized management: Manage all credentials from one secure location
Easy rotation: Update keys in 1Password without touching shell configuration
Safe version control: Your .zshrc can be safely committed without exposing secrets

Performance Considerations

You might wonder about the performance impact of calling op for each key. In practice, the CLI is quite fast, but if you're concerned about startup time, you could implement caching:

# Cache keys for the session
if [[ -z "$GEMINI_API_KEY" ]]; then
    export GEMINI_API_KEY=$(op item get 'Gemini CLI' --fields password --reveal)
fi

Alternative: Session Management

For even better security, you can use 1Password's session management to avoid keeping long-running authenticated sessions:

# Sign in and export session token
export OP_SESSION_my_account=$(op signin my_account --raw)

# Use the session token for subsequent calls
export GEMINI_API_KEY=$(op item get 'Gemini CLI' --fields password --reveal --session="$OP_SESSION_my_account")

Conclusion

By leveraging 1Password CLI, we can maintain the convenience of environment variables while significantly improving our security posture. Your API keys remain encrypted at rest, access is audited, and you eliminate the risk of accidentally exposing secrets in version control.

The small performance overhead is a worthwhile trade-off for the security benefits, and your future self will thank you for taking the extra step to protect your valuable API credentials.

📸 Swift Camera — Part 1

Fri, 16 Jun 2017 13:28:59 GMT

Create a custom camera view using AVFoundation

Photo credit: unsplash

iOS 11 brings lots of new cool features like Machine Learning and Augmented Reality. So you might want to test those features or create awesome apps. But if you notice that some of them need a custom camera and accessing camera frames. iOS have lots of API’s for us to access device camera, capture image and process it. AVFoundation is the framework you should be looking at. Since this framework is huge and there is lots of ways to achieve the desired features I decided to write set of blog posts about the following.

Create custom camera view
Take picture from custom camera
Record Video using
Detect Face and Scan QR code

(If you want some specific things please do ask me in the comments. I will try to write/learn about it)

To all those nerds who wants to skip the blog post and see the code in action. I got you covered. Here is the Github Repo. Keep an eye on this repo because I will be adding all features in the same app and if you want to improve the code quality PR/Issues are welcome.

rizwankce/Camera

For others,

Let’s create a custom camera

Step 1:

Create new project in xCode by selecting File → New → Project → Single View Application (under iOS tab)

Give it a nice name and select swift as Language. Click Next → Create and save the project file. if everything goes well, you could see a project like below

<img src="https://cdn-images-1.medium.com/max/800/1*hoxX5t0dPha_Y4XzMFucCQ.png"> Project structure

Step 2:

Select Main.storyboard ,drag UIView to your view controller and set top , bottom , leading, trailing to 0. This view will serve as “view finder” or “preview view” for your camera.

<img src="https://cdn-images-1.medium.com/max/800/1mvbETYE-5CJa6t_ZlxjOtg.png"> Main.storyboard ViewController structure <img src="https://cdn-images-1.medium.com/max/800/1wUAgn8DwN0rXZ65Tcak4Xw.png"> Preview View Constraints

Control + drag our preview view to ViewController.swift and create an IBOutlet named previewView

Step 3

At the top of your ViewController file, import AVFoundation framework.

import AVFoundation

Create the below instance variables so that we can access anywhere in the ViewController file.

var captureSession: AVCaptureSession?
var videoPreviewLayer: AVCaptureVideoPreviewLayer?

here captureSession helps us to transfer data between one or more device inputs like camera or microphone and view videoPreviewLayer helps to render the camera view finder in our ViewController

Step 4

You will need a capture device, device input and preview layer to setup and start the camera. To make it simpler we will try to do everything related to camera setup in viewDidLoad

Get an instance of the AVCaptureDevice class to initialise a device object and provide the video as the media type parameter. You can even select which capture device you can choose like a dual camera or standard camera but for this post, we will just get default device (rear camera).

let captureDevice = AVCaptureDevice.defaultDevice(withMediaType: AVMediaTypeVideo)

Get an instance of the AVCaptureDeviceInput class using the previous device object. This will serve as a middle man to attach our input device to capture device. Here there is a chance that input device might not be available, so wrap it inside a do…catch to handle errors

do {
let input = try AVCaptureDeviceInput(device: captureDevice)
} catch {
print(error)
}

Initialise our captureSession object and add the input device to our session

captureSession = AVCaptureSession()
captureSession?.addInput(input)

Next configure our preview View so that we can see the live preview of camera.

Create an AVCaptureVideoPreviewLayer from our session
Configure the layer to resize while maintaining original aspect
Set preview layer frame to our ViewController view bounds
Add the preview layer as sublayer to our previewView

videoPreviewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
videoPreviewLayer?.videoGravity = AVLayerVideoGravityResizeAspectFill
videoPreviewLayer?.frame = view.layer.bounds
previewView.layer.addSublayer(videoPreviewLayer!)

Finally, start our captureSession to start video capture

captureSession?.startRunning()

Step 5

Since the simulator does NOT have a camera to check our code. you might need a real device to run the code. So connect your phone and hit run, you should be see a live camera.

Meh! The app will crash because we forgot to add one last thing. That is “Privacy — Camera Usage Description” in our plist. Add this to Info.plist file and give some nice message because that is what user will see when app is requesting for camera permission.

Now if you hit run you should be seeing the magic!

There are some things which I haven’t included here like checking user permission, adding capture output. But if you got the time you can read about all of them in Apple Documentation here.

Photo Capture Programming Guide

On next part, I will write about having AVCapturePhotoOutput and use its delegate method to take a picture and save it to iPhone Camera Roll. Follow me here or on twitter to get updates. If you like this post share and comments

📸 Swift Camera — Part 2

Tue, 20 Jun 2017 12:01:15 GMT

Use custom camera view to take pictures and save it to photos album

Photo credit: Unsplash

Incase this is your first time here, you can go ahead read the part 1. Believe me — it would only take you 4 mins to read it. I explained in detail about “How to create custom camera view using AVFoundation

📸 Swift Camera — Part 1

As usual, to all those nerds who wants to see the code in action and skip this post. Here is your Github repo link. Everything I am gonna discuss is already in that repo master branch.

rizwankce/Camera

For others who want to learn before diving into code,

Let’s take pictures with our custom camera

Before you dive in, you need the code from Part 1. You can find it in this Github branch. Below steps will use the part 1 view controller and add a feature to taking pictures.

Step 1

Select Main.storyboard, drag UIButton to our view controller, give it a nice title like “Snap a photo” and set constraints. Make sure button is on top of the preview view like below.

<img src="https://cdn-images-1.medium.com/max/800/1*ul8unoF8WI3gkcVJotHoMQ.png"> Main.storyboard ViewController structure

Set below constraints for our button, So that it will be in correct position.

<img src="https://cdn-images-1.medium.com/max/800/1*rHzGPk6R8CNpy26m8VVzaw.png"> Capture button constraints

Here, I’m adding leading, trailing and bottom constraints to our capture button. So that our button will be placed the bottom of the screen.

Control + drag our button to ViewController.swift and create an IBOutlet action like below. This function will be called when we tap the capture button.

@IBAction func onTapTakePhoto(_ sender: Any) {

}

Step 2

Create below instance variable in our ViewController.

var capturePhotoOutput: AVCapturePhotoOutput?

Here capturePhotoOutput helps us to snap a photo from our capture session. It has also provided lots of modern interface for capturing still photo, Live photo, wide-gamut colour including the variety of formats. To simplify this post, we are going to take still image from our capturePhotoOutput.

Step 3

Create an instance of AVCapturePhotoOutput in our viewDidLoad method inside do…catch loop and add it to our session as output like below.

// Get an instance of ACCapturePhotoOutput class
capturePhotoOutput = AVCapturePhotoOutput()
capturePhotoOutput?.isHighResolutionCaptureEnabled = true

// Set the output on the capture session
captureSession?.addOutput(capturePhotoOutput)

AVCapturePhotoOutput has lots of properties to control how the capture workflow should work. But we are just enabling High resolution capture here.

Step 4

Create and configure Photo Settings in our onTapTakePhoto function like below.

// Make sure capturePhotoOutput is valid
guard let capturePhotoOutput = self.capturePhotoOutput else { return }

// Get an instance of AVCapturePhotoSettings class
let photoSettings = AVCapturePhotoSettings()

// Set photo settings for our need
photoSettings.isAutoStillImageStabilizationEnabled = true
photoSettings.isHighResolutionPhotoEnabled = true
photoSettings.flashMode = .auto

// Call capturePhoto method by passing our photo settings and a
// delegate implementing AVCapturePhotoCaptureDelegate
capturePhotoOutput.capturePhoto(with: photoSettings, delegate: self)

Here, create an instance of AVCapturePhotoSettings and set some photo settings like image stabilisation, high resolution photo and auto flash mode.

Then, call capturePhoto method from capturePhotoOutput instance and pass our photo settings with self as delegate. This will allow us to take a still image from our custom camera.

Step 5

AVCapturePhotoCaptureDelegate methods gives us lots of control over a photo capture output. To simply our needs we will use this below method to get the captured image.

photoOutput(_:didFinishProcessingPhoto:previewPhoto:resolvedSettings:bracketSettings:error:)

Create an extension for ViewController and extends from AVCapturePhotoCaptureDelegate like below

extension ViewController : AVCapturePhotoCaptureDelegate {
    func capture( captureOutput: AVCapturePhotoOutput,
                  didFinishProcessingPhotoSampleBuffer photoSampleBuffer: CMSampleBuffer?,
                  previewPhotoSampleBuffer: CMSampleBuffer?,
                  resolvedSettings: AVCaptureResolvedPhotoSettings,
                  bracketSettings: AVCaptureBracketedStillImageSettings?,
                  error: Error?) {
        // get captured image
}

didFinishProcessingPhotoSampleBuffer gives us the captured photo buffer ,preview buffer and resolved photo settings.

// Make sure we get some photo sample buffer
guard error == nil,
    let photoSampleBuffer = photoSampleBuffer else {
        print("Error capturing photo: \(String(describing: error))")
        return
}

// Convert photo same buffer to a jpeg image data by using // AVCapturePhotoOutput
guard let imageData =
    AVCapturePhotoOutput.jpegPhotoDataRepresentation(forJPEGSampleBuffer: photoSampleBuffer, previewPhotoSampleBuffer: previewPhotoSampleBuffer) else {
        return
}

// Initialise a UIImage with our image data
let capturedImage = UIImage.init(data: imageData , scale: 1.0)
if let image = capturedImage {
    // Save our captured image to photos album
    UIImageWriteToSavedPhotosAlbum(image, nil, nil, nil)
}

Here, we are getting only photoSampleBuffer. Need to convert it to a jpeg image data. To do that we can use jpegPhotoDataRepresentation method from AVCapturePhotoOutput which will take photo sample buffer and preview photo same buffer as input and gives us JPEG image data.

To save our captured image to photos album, again we need to convert our image data to UIImage . So initialise an UIImage by passing our jpeg Image Data and scale of 1.0.

Finally, use UIImageWriteToSavedPhotoAlbum method and pass our image to be saved in photo album.

Step 6

if you run the app in a real device, it might crash now by giving below message.

Console message on Crash

You guessed it correct! we need to add “Privacy — Photo Library Usage Description” in our plist. Since we are saving the image to photo library.#

EDIT from future

To prevent crashes on iOS 11, “Privacy — Photo Library Additions Usage Description” in info.plist with a usage description (string) should be added.

Thanks to Ingrid Silapan for pointing this out!

Now if you hit run and click the button at the bottom. You will hear a sound indicating the camera is taking picture. Go ahead and check in your photos app to verify the captured image is actually saved or not.

There are lots of things I haven’t included here. So I am trying to list as much as possible below.

AVCapturePhotoOutput class supports only from iOS 10 and above. So if you are targeting any iOS below then 10. You should be checking out [AVCaptureStillImageOutput](https://developer.apple.com/documentation/avfoundation/avcapturestillimageoutput)
[didFinishProcessingPhotoSampleBuffer](https://developer.apple.com/documentation/avfoundation/avcapturephotocapturedelegate/2873949-photooutput) is deprecated from iOS 11. But you can use didFinishProcessingPhoto method from AVCapturePhotoOutputDelegate to achieve the same for iOS 11
The reason these photo taking API’s from Apple is deprecated and added for every major release is that every major iOS release is included with lots of feature for photo capture. Do you know that you can take the RAW image file and save it as DNG and can be edited with your favourite photo editing app without losing any image data? Yes, its possible from iOS 10
AVCapturePhotoOutput is so powerful that we need to take a bit more time to avoid errors. I would suggest reading more on “Photo Capture programming guide”
To save image to photos album we have used UIImageWriteToSavedPhotoAlbum method. But if you want more control over saving photos, you need to check out [PHPhotoLibrary](https://developer.apple.com/documentation/photos/phphotolibrary) Since photos app is become so powerful, starting from iOS 8 now we have more control over Photo Library as well.
Having a “Snap a photo” button seems to be old-school. So I created a rounded white background button and the same code is available in Github repo.

On next part, I will write about detect QR code or Face from our custom camera view. Follow me here or on twitter to get updates. If you like this post please share and recommend.

📸 Swift Camera — Part 3

Wed, 05 Jul 2017 08:59:57 GMT

Use custom camera view to detect QR code

Photo by Nadine Shaabana on Unsplash

This is third part of “Swift Camera” series. You can check those from below

📸 Swift Camera — Part 1

📸 Swift Camera — Part 2

As usual, project code is available in Github from all parts.

rizwankce/Camera

Before we dive in, you need to check the code from Part 1 where we discuss about creating custom camera view. Below steps will use the same view controller as other part and add detecting QR code feature to it.

AVFoundation provides set of API’s to detect the barcodes from our custom camera. To check the list of supported barcode type check AVMetadataObject.ObjectType . In this post we will learn about detecting QR (Quick Response) code.

Step 1

Create an instance of AVCaptureMetaDataOutput in our viewDidLoad method inside do…catch loop and add it to our session as output like below.

// Initialize a AVCaptureMetadataOutput object and set it as the
// input device
let captureMetadataOutput = AVCaptureMetadataOutput()
captureSession?.addOutput(captureMetadataOutput)

To make a note our captureSession can add more then one output. In our example we are having AVCapturePhotoOuput and AVCaptureMetadataOutput to simultaneously take photo or read meta data from single camera view.

Step 2

Set delegate for MetadataObjectsDelegate and metadataObjectTypes like below.

// Set delegate and use the default dispatch queue to execute the
// call back
captureMetadataOutput.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
captureMetadataOutput.metadataObjectTypes =\[AVMetadataObjectTypeQRCode\]

Here, meta data object delegate requires a dispatch queue. To simplify it, we are going with Main queue. But for production application it’s better to create a serial queue for our delegate.

Let captureMetadataOutput know what type of object types we need to detect. It accepts array of meta data types. If you want to detect all supported types just list them in an array.

Step 3

AVCaptureMetadataOutputObjectsDelegate methods gives us meta data objects which was detected from our capture session.

Create an extension for ViewController and extends from AVCaptureMetadataOutputObjectsDelegate like below

extension ViewController : AVCaptureMetadataOutputObjectsDelegate {

    func captureOutput(\_ captureOutput: AVCaptureOutput!,
        didOutputMetadataObjects metadataObjects: \[Any\]!,
        from connection: AVCaptureConnection!) {
        // get detected meta data
    }
}

didOutputMetaDataObjects delegate method will give us detected meta data objects from our connection.

let metadataObj = metadataObjects\[0\] as! AVMetadataMachineReadableCodeObject
if metadataObj.type == AVMetadataObjectTypeQRCode {
   if metadataObj.stringValue != nil {
      debugPrint(metadataObj.stringValue)
   }
}

Here, we are casting our meta data object to AVMetaDataMeachineReadableCodeObject first and checking whether it is type of QR code or not. stringValue from meta data object is our decoded QR code message.

Meta data object does provide the detected QR code frames. So we can show the detected frames in our camera preview as well. To get the frames use transformedMetaDataObject method from AVVideoPreviewLayer class.

let barCodeObject = videoPreviewLayer?.transformedMetadataObject(for: metadataObj)

barCodeObject.bounds will give us the frames of detected code.

If you want to detect the Face on camera view, we can follow the same method as QR code and add face type for metadataobjects. Check out m Github repo branch for more info.

rizwankce/Camera

iOS 11 has new Vision API’s to detect QR codes as well. Documentation is not mature enough yet. Still trying to figure out how to read QR with Vision API
Example project on Github has more functions like display the detected QR code in a UILabel and draw a square on camera preview by using detected meta data bounds.

Though Swift Camera series ends here. I will write tiny post in future for sure. So follow me on here or twitter to get updates. I would like to thank ComplieSwift editor and everyone who recommended and followed me on medium.

SwiftUI Color Scheme

Wed, 22 Jul 2020 00:00:00 GMT

In UIKit app, If you would like to change the color scheme within the app. Setting UserInterfaceStyle object to your root window would help.

Take a look at NetNewsWire iOS app. It gives Appearance settings where you can choose your color palette for the app. These are the possible options

Automatic: respects system color scheme and changes whenever user switching between light and dark mode from the OS
Light: Light mode for the whole app and didn't respect the system color scheme
Dark: dark mode for the whole app and didn't respect the system color scheme

func updateUserInterfaceStyle() {
  switch AppDefaults.userInterfaceColorPalette {
    case .automatic:
      window!.overrideUserInterfaceStyle = .unspecified
    case .light:
      window!.overrideUserInterfaceStyle = .light
    case .dark:
      window!.overrideUserInterfaceStyle = .dark
  }
}

Setting unspecified makes the app respects the system-wide color scheme here.

SwiftUI Way

SwiftUI gives us an environment variable and preferred color scheme modifier to change the color scheme.

struct ContentView: View {
    @State var preferredColorScheme: ColorScheme? = nil

    var body: some View {
        List {
		        Button(action: {
                preferredColorScheme = .light
            }) {
                HStack {
                    Text("Light")
                    Spacer()
                    if preferredColorScheme == .light {
                        selectedImage
                    }
                }
            }

            Button(action: {
                preferredColorScheme = .dark
            }) {
                HStack {
                    Text("Dark")
                    Spacer()
                    if preferredColorScheme == .dark {
                        selectedImage
                    }
                }
            }
        }
        .listStyle(InsetGroupedListStyle())
        .preferredColorScheme(preferredColorScheme)
        .navigationBarTitle("ColorScheme Test")
    }

    var selectedImage: some View {
        Image(systemName: "checkmark")
            .foregroundColor(.blue)
    }
}

In the above code, we are setting the preferredColorScheme modifier to our content view and changing it via @State object. It will give us one view with two options where you can change the color scheme.

It's also possible with the environment value like below

@main
struct ColorSchemeTestApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(\.colorScheme, .dark)
        }
    }
}

We can also get to know the currently selected color scheme via environment object like below.

@Environment(\.colorScheme) var colorScheme

NOTE

As of beta 2, there is no way that I can find, to set the colorScheme to unspecified to get automatic behaviour. I have even filed a Feedback. In case if you find a way to achieve it, let me know at twitter

I did create a sample project to explain the behaviour and you can find it here at Github.

SwiftUI Import/Export files

Sat, 18 Jul 2020 00:00:00 GMT

Future Me: Things have changes with Xcode beta and this post is outdated. Please take a look at part 2 of this blog here

As discussed on my previous blog post, kickstarting my learnings from contributing to SwiftUI open source project. In this blog post, I try to explain what I have come across very recently which was missed out during WWDC and impressed when I came to know about it. It's about import and exporting files.

In traditional UIKit, whenever you want to export or import files. We have to rely on UIDocumentPickerViewController. Here is the sample code from NetNewsWire iOS app where we try to export and import OPML files.

Importing files

let docPicker = UIDocumentPickerViewController(documentTypes: opmlUTIs, in: .import)
docPicker.delegate = self
docPicker.modalPresentationStyle = .formSheet
self.present(docPicker, animated: true)

Above code will present a document picker and user can select any OPML files from the Files app.

Exporting files

let docPicker = UIDocumentPickerViewController(url: tempFile, in: .exportToService)
docPicker.modalPresentationStyle = .formSheet
self.present(docPicker, animated: true)

Above code will present a document picker and user can export the OPML files to the Files app.

SwiftUI way

We saw what it takes to import and export files in UIKit. But in SwiftUI all it takes is one environment object.By utilising the all new export and import files environment values we could easily add support to our SwiftUI apps for import/export functions.

Step 1

At first, define the environment object on your View

@Environment(\.exportFiles) var exportAction
@Environment(\.importFiles) var importAction

Step 2

Use the environment variable to export or import files. As like UIKit importing action needs file types and exporting action needs the temporary file urls.

// consider you have file temporary url
exportAction(moving: url) { _ in }

importAction(multipleOfType: types) { (result: Result<[URL], Error>?) in
	if let urls = try? result?.get() {
		// you can do with the file urls here
	}
}

It's also possible to import/export multiple files.

Check out more on my PR on Github for how it works on NetNewsWire app.

UniformTypeIdenfiers

SwiftUI also comes with a new framework for all UTTypes and it's called UniformTypeIdentifiers. This also helps us to define what kind of files we can choose from. It comes with predefined files types and you can find all the system declared types here.

For any specific case, we can also create our own UTType with file extensions as well. Here is the code to select only OPML files.

let type = UTType(filenameExtension: "opml")

Links

Check out more info on Apple documentation

SwiftUI Import/Export files - Part 2

Wed, 07 Oct 2020 00:00:00 GMT

There were lots of changes this year during the Xcode and iOS beta. Typically we will get major new features on initial beta and subsequent beta will have only bug fixes. This year is a little bit different, we even got changes to Swift UI at the end of the beta cycle.

Beta 6 made a change for SwiftUI import/export files. Instead of environment variable now its a modifier. My previous blog post is outdated and now that Xcode 12 is out, I guess these needs follow up post.

Importing

To import file, we have to use the fileImporter modifier. There is no limit where you have to use this modifier. It's working same as presenting sheets before.

.fileImporter(
      isPresented: $viewModel.isImporting,
      allowedContentTypes: viewModel.importingContentTypes,
      allowsMultipleSelection: true,
      onCompletion: { result in
        if let urls = try? result.get() {
          // you can do with the file urls here
        }
      }
    )

The parameters were self-explainable. It takes

a Binding<Bool> for presented statues
an array of content types [UTType]
a bool to allow multiple selections while importing
a completion block when the import is success

Exporting

To export files, we have to use the fileMover modifier.

.fileMover(isPresented: $viewModel.isExporting,
           file: viewModel.generateExportURL()) { _ in }

File mover takes a Binding<Bool> for presented status and the URL of the file which needs to be exported.

In case, if you would like to know a working example, take a look at this PR I have raised for NetNewsWire app.

TestFlight Review Times

Wed, 03 Jun 2020 00:00:00 GMT

If you ever submitted an app update recently to TestFlight review on App Store Connect, you know the time take to get it approved. It was the case for even App Store app updates some time back. Recently Apple is improving the total time taken for review resulting in one day review time (some developers from US time zone can get even less then an hour)

At my work, we do have multiple beta groups and most of the time a new update would take more then 2 days to get it reviewed for TestFlight. Its doesn't work for urgent release. So we changed the release process little bit different and always keep the TestFlight app updates near instant.

The way TestFlight update works is every new version update has to go to review and every build on the same version is apporved immediately.

So whenever we released a version to App Store, immediately we submit the same build again for TestFlight app review by bumping the version number. By the time we finish developing the app update, the initial version submitted to review would be approved and submitting second build on same version would get approved immediately.

For example, after releasing v5.0 to App Store, try submitting v5.1 (or whatever version on your pipeline) with the same build as v5.0. Only change here is version number. By the time you actually wants to push v5.1 for your beta testers. Just bump the build number and submit. It will be approved immediately.

Above works fine as of dated. Who knows WWDC 2020 might have some improvements.

Tracker Prevention for WKWebView

Wed, 12 Aug 2020 00:00:00 GMT

In 2017, Apple WebKit team announced "Intelligent Trackers Protection" feature which blocks cross-site trackers and cookies. Slowly WebKit team is adding new features to WebKit and bringing the same to Safari.

Safari 14

Safari 14 improves ITP and by default, it will block all the cross-site trackers by using on-device machine learning to identify trackers and the known trackers are identified by DuckDuckGo. Safari not only blocks the trackers, but it will also list all the trackers and websites in detail. Here is the screenshot of all trackers blocked from Safari 14. I have been using it from beta 1.

WKWebView

The interesting thing with ITP is we (third party developers) can start using it for our in-app browsers which uses WKWebView without any extra effort. It comes free when you use WKWebView and you have iOS 14 or macOS Big Sur installed.

In case if we want to opt-out from this default behaviour, we could simply set the purpose string NSCrossWebsiteTrackingUsageDescription in Info.plist. When present, this key causes the application’s Settings screen to display a user control to disable ITP. The setting cannot be read or changed through API calls.

NOTE: As of beta 4, I couldn't get the settings even after adding purpose string. Probably it will work on upcoming beta's

Incase if the app wants to be "Default Browser", purpose strings is not necessary.

Uses

Thu, 07 May 2020 00:00:00 GMT

Inspired from wesbos’s /uses trying to gather all the things I use.

Hardware & Accessories

MacBook Pro 15 inch - 2016 - i7, 16 GB RAM, 512 GB SSD, Radeon Pro 455 2 GB Graphics
1st gen Magic keyboard / Keychron k2
Logitech MX Master 3
iPhone 11 Pro
Roost laptop stand
Bose QC II / AirPods 1st gen

Software

Xcode - ٩(◕‿◕｡)۶
App code - for good old Objective-C
VS Code - for everything else
Nova from Panic - beta testing and mainly for React and React Native
Paw / Postman - for all my HTTP test
Sip - color picker - to pick color from anywhere on the screen
1Password - weapon of choice for password manager
NetNewsWire - RSS reader
Source Tree - Git
Things 3 - Goto task manager
iTerm2 - Terminal of choice with zsh
Contraste - Color picker and a11y checker
Dev Cleaner - to clear everything from Xcode
Hidden Bar - to hide menu bar icons
One Switch
Pastebot - clipboard manager
Tot - stickies notes but better

Others

Font of choice - Dank Mono
Cobalt 2 theme on VS Code and custom Metro lights theme for Xcode
Backups are in iCloud - having 50GB tier
Dotfiles are in GitHub

When Not to Delegate to LLMs

Mon, 20 Oct 2025 00:00:00 GMT

We're living in the age of LLMs and coding agents - tools like Claude Code, GitHub Copilot, and various CLI assistants promise to accelerate our development workflow. And they do, most of the time. But there's a catch: not every task is a good fit for delegation to these tools.

The Storyboard Refactoring Story

Recently, I needed to refactor some Storyboard files in an iOS app. (Yes! Im stuck with work app on Storyboard files) Since Storyboards are XML-based, I thought this would be a perfect task for Claude Code or similar tools. Text manipulation is what LLMs excel at, right?

Turns out, I was wrong.

The problem wasn't the XML itself - it was everything around it. Xcode project files have their own special format. They maintain complex references between files, build configurations, and project settings. Interface Builder has specific constraints about how UI elements can be structured. Breaking any of these invisible rules means your project either won't build or will crash at runtime with cryptic errors.

I spent more time debugging the LLM's output, fixing broken references, and troubleshooting build errors than I would have spent doing the refactoring myself. When I finally gave up and did it manually, it took about 5 minutes.

When LLMs Struggle

Three patterns trip them up:

Tight file formats: Xcode projects, Storyboards, and other bespoke files crash if a single reference goes missing.
Toolchain nuance: An LLM hasn't spent years with Xcode, Gradle, or your CI, so it misses the small switches that keep things running.
Tiny chores: If you can do it in minutes, the prompt-review-fix loop is slower than typing it yourself.

The Real Skill

Before delegating, run through a fast checklist:

Does this rely on niche tooling or hidden rules?
Can I finish it in under 10 minutes solo?
Will I spend more time vetting the output than producing it?

Any yes means I stay hands-on.

WWDC 2020 Wish-list

Fri, 22 May 2020 00:00:00 GMT

I wrote my thoughts on WWDC 2020 wish-list on twitter. Here is the list not in any particular order but hope to see it in real.

Also, did I tell you? This will be my first ever WWDC. Since It's online and free for everyone.

https://twitter.com/rizzu26/status/1258537074556194818?s=20

https://twitter.com/rizzu26/status/1258537254894485504?s=20

https://twitter.com/rizzu26/status/1258537413271416832?s=20

https://twitter.com/rizzu26/status/1258537588513619968?s=20

https://twitter.com/rizzu26/status/1258538534295621633?s=20

https://twitter.com/rizzu26/status/1258538768350375937?s=20

https://twitter.com/rizzu26/status/1259826268444307456?s=20