Home - Tom Barrasso

Introducing iClaw, a safe, private, on-device AI agent using Apple Intelligence

blog@barrasso.me (Tom Barrasso) — Mon, 27 Apr 2026 00:00:00 GMT

I recently shared Junco, an on-device AI agent that uses Apple Intelligence to write and edit Swift code. Today I’m sharing iClaw, an experimental local AI agent for macOS designed around safety and privacy.

Screen recording of iClaw local AI agent on macOS

iClaw started as a SundAI hackathon project in March. Although our demo failed, we learned many lessons I’ll share. But first:

Why Build iClaw? #

Technologies like OpenClaw are transformative, and while it’s among the fastest-growing GitHub repositories, it hasn’t crossed the chasm into mainstream use. I suspect non-technical users lack the time, knowledge, patience, and risk appetite to purchase a Mac Mini and AI credits, configure agents, and give them access to their personal accounts.

iClaw is fundamentally different. It’s designed to use the AI you already have (Apple Intelligence), without buying credits or a subscription. Built inside Apple’s App Sandbox, iClaw focuses on safety, security, and privacy: it only accesses files, data, and accounts you give it explicit permission to. As a bonus, on-device AI is green—using orders of magnitude less energy than frontier data centers.

What can iClaw do? #

At present, iClaw is basically a bad Siri. Ask it for the weather, a stock quote, a Wikipedia summary, or some basic math. It uses Apple’s tools to read calendar events, search through email, transcribe a podcast, or translate a document. But iClaw (and general-purpose on-device AI) has some major limits today. Small models excel at executing a single, narrowly defined task, but they fail at task decomposition and “reading between the lines.” If you don’t spell out exactly what you want, on-device AI models are much more likely to make mistakes.

Some of iClaw’s key features include:

Just-in-time Permissions. iClaw doesn’t use blanket permissions or policies. It lives in the App Sandbox and asks permission whenever it wants to read your Calendar or send an iMessage.
Browser Bridge. iClaw can read and interact with Safari, Chrome, or Firefox through a Web Extension.
Dynamic Widgets. iClaw creates on-the-fly widgets using it’s own DSL, so you don’t have to read a wall of text.

What’s exciting is what iClaw could do with an updated model and an improved harness.

What could iClaw do? #

iClaw suffers because it tries to augment a constrained model (Apple’s 3B Foundation Model) with natural language processing (NLP) and machine learning (ML) classifiers. As a task gets more complex, or the number of tools expands, the model gets distracted, makes mistakes, or outright refuses to do anything!

In building iClaw, I’ve explored lots of applications and integration surfaces. Of the many ideas I had for iClaw, a few still hold promise.

Personalized Email Triage: use MailKit and Apple Intelligence to privately and securely triage, tag, filter, forward, and delete incoming emails
Mac-iPhone Continuity: use Apple Intelligence and iCloud Sync to search your MacBook’s files via Spotlight on the go from your iPhone
Automate Everything: use Apple Intelligence to author custom AppleScript automation for transcription, conversion, batch image editing, and more
Background Browsing: natively bridge a Safari Extension to Apple Intelligence so AI can browse real estate listings, classifieds, and social media on your behalf
Learned Skills: Skills written in Markdown are simple, but not intuitive for the average user. A better approach would be to “learn” common tasks and codify them into Skills

Apple itself may be exploring similar applications, with rumors of “Campos”, an AI-powered Siri chatbot with access to Photos, Mail, Messages, and more.

Why On-Device? #

Local models aren’t just about privacy — they’re about business strategy, unit economics, and experiments that indicate venture capital subsidies are ending. It will always be more cost-effective in the long run to use the compute you already have, rather than lease it from someone else.

Local Tradeoffs #

There’s no such thing as a free lunch. Apple’s 3B Foundation Model is arguably one of the worst contenders for an on-device agent. It’s terrible at following instructions, has a minuscule 4,096-token context window, doesn’t offer a native thinking mode, has aggressive safety guardrails, and can be extremely flakey. Then there are concerns related to how AI affects battery life, uses tons of memory, and serves inference sequentially (so your app might have to wait its turn). Despite these shortcomings, Apple Intelligence can still be quite useful for tasks like summarization, redaction, pattern matching, and search augmentation.

What about other models? #

My laptop is a 24GB M4 MacBook Air, which by most standards is fairly capable. Yet when it comes to local models, 24GB really limits what’s possible. iClaw natively supports Ollama, so you can bring-your-own-model (BYOM). I’ve tested quantized (Q4_K_M) versions of Gemma 4 E4B and Qwen3.5-4B. Both generally performed better than the AFM at routing, judging, and responding in a conversational way. However, both were noticeably slower and had a tendency to ramble. This is of course subjective and likely hardware-dependent, but for most macOS users, the fastest and most efficient on-device AI model is almost certainly Apple’s Foundation Models.

What I Learned #

1. Just a few tools #

Early screenshot of iClaw listing podcasts using Gemma 4 E2B with Ollama

Arguably it’s better to do one thing well, rather than many things poorly.

Tool calling is an important capability that allows AI models to access your files, contacts, messages, or the web. Early versions of iClaw actually worked well, but when our tool count ballooned from 4 to 14, we quickly realized that the AFM was basically calling tools at random, or not at all.

Small models like the Apple Foundation Model (AFM) get easily distracted, so if you’re building on Apple Intelligence it’s best to limit the model’s tool choice to just 2 or 3. A major challenge in AI is testability and reproducibility. If your app has fewer tools, fewer settings, and fewer features, there are fewer state combinations to worry about.

2. No context snowballs #

All AI models, including frontier models, get lost in the middle. On small models, context rot and bloat will completely derail an agent. OpenClaw has session pruning, OpenCode has a /compact command, and Claude can dream. These are all strategies for pruning context to keep it relevant and stay within context window limits.

For small models like the AFM, don’t let your context snowball. Instead, build scaffolding that keeps you well within the 4,096-token window and avoids the most devastating failure modes. iClaw ships with several text classifiers that act as tool routers.

Rather than ask the model which of 40+ tools to use, iClaw uses a small classifier that runs in milliseconds. This too can fail, but it will do so deterministically. Sometimes deterministic failure can be an advantage. Consider ShellTalk, a text-to-bash utility I built. Changes can be tested against hundreds of cases in minutes. If you can reliably measure accuracy, you can use a technique like Meta-Harness or Autoresearch to autonomously and continuously drive improvements.

3. Lower your expectations #

Early screenshot of iClaw dynamically generating a comparison table

I had dozens of ideas for iClaw. One notable idea took inspiration from Agent-to-UI (A2UI): dynamically rendering widgets, rather than a wall of text. Early tests worked! The AFM could output a custom, token-efficient, XML-like domain-specific language (DSL) to render lists, tables, images, and chips. But it wasn’t long before the model started spitting out tables with strange layouts: duplicating headers, misaligning columns, or omitting key data.

My second approach involved training a custom adapter and pre-generating templates for a slot-fill strategy. This worked better in that it prevented the most egregious failure modes, but it was still far from consistent.

My advice: lower your expectations. On-device AI will make more mistakes, so give it fewer tasks to mess up. For now, this is the price you pay when your cost per million tokens is $0.

4. Other lessons #

Nested choices #

Replace flat lists–weather, calendar, messages, news–with clustered domains–media and communication. Nested and hierarchical choice enhances user experience by reducing mental load, and improves model performance by reducing tool selection errors. Local models have the benefit of zero network latency, so they are better suited at sequential tasks. Again, these models are hopeless if you give them 40 tools, but use a classifier to pick 1 of 8 domains, then ask the model to select when of the 3 tools in that domain to use.

Arithmetic and hallucinations #

AI models are still bad at math. Don’t ask the AFM to do arithmetic, format dates, or convert units — it will confidently get them really wrong. Instead, have tools return facts and let the LLM rephrase these into natural language. Emit LaTeX, timezone identifiers, and precisely-formatted numbers then verify the model’s output against the formatted inputs.

Don’t pollute the context #

One unhandled exception can pollute an entire context chain. If a tool returns an error, and that error gets passed as context into the next turn with the model, prompt outputs can go way off track. Catch errors, and either retry deterministically or ask the LLM to heal certain classes of errors. When it’s not possible, ask the LLM to phrase the error in a human-readable way. Error handling is definitely not a solved problem and LLMs offer an entirely new class of vulnerabilities and errors to deal with.

Rewind the tapes #

Ruby’s VCR library is still one of my favorites. Unit tests need to be reliable, repeatable, fast, and thorough in order to be informative. Like HTTP requests, LLM responses are non-deterministic. Consider running, storing, and replaying past responses so your unit tests are consistent.

Tactical advice #

The AFM does not have a lot of levers: no public weights to adjust, no thinking or reasoning modes, and no constrained grammar. What it does have, you should use:

Limit response size (and lower response time) with maximumResponseTokens
Make responses more predictable by adjusting the temperature
Make diverse but constrained choices by setting the sampling mode
Call prewarm to reduce latency, cache a prompt prefix, and affect memory residency
Use InstructionsBuilder to increase instruction compliance

The right prompt and appropriate settings can actually produce dramatic improvements!

What’s Next? #

iClaw is available for free with code on GitHub. I’ll be applying these lessons, and learning many more, as I continue building iClaw and local-first AI products. Stay tuned for more!

Deterministic text-to-bash with ShellTalk

blog@barrasso.me (Tom Barrasso) — Wed, 22 Apr 2026 00:00:00 GMT

I recently released ShellTalk, an Apache 2.0 licensed CLI and library that converts natural language English text into the Bash commands.

shelltalk "find all images in this folder"
find . -type f \( \
 -name '*.jpg' -o \
 -name '*.jpeg' -o \
 -name '*.png' -o \
 -name '*.gif' -o \
 -name '*.webp' -o \
 -name '*.svg' \
\)

While building Junco, I discovered Hunch, an on-device CLI that uses Apple Intelligence and few-shot dynamic retrieval to convert text to bash. The concept was fascinating, and proved that even a small non-coding model like the 3B Apple Foundation Model (AFM), with guardrails, is capable of producing valid Bash scripts from natural language input.

Using the AFM is ideal because it’s incredibly optimized and comes pre-installed on many Macs with macOS 26 Tahoe. However, it’s not truly portable since it has a runtime dependency on a limited-availability small language model (SLM). Given that single-command bash is a pretty constrained space, I hypothesized that this might be possible without LLMs at all. My approach for ShellTalk was leveraging Semantic Template Matching (STM) to map intent → command.

Why no LLMs? #

On-device AI keeps getting better, cheaper, and more efficient, but it’s not a panacea. It’s still not easily accessible on many environments like embedded devices, older mobiles, or the web. Beyond LLMs, Natural Language Processing (NLP) has continued to advance with more efficient embedding models that come pre-packaged into many runtimes like Apple’s NLEmbedding introduced in macOS/ iOS 13.

Moreover, deterministic approaches are typically faster and easier to reproduce, resulting in shorter testing and iteration cycles. Given text-to-bash has relatively constrained inputs and outputs, I figured a tool like Claude Code could quickly prototype and iterate autonomously towards a working solution similar to Meta-Harness. Effectively, this technique builds a system that build systems.

How ShellTalk works #

ShellTalk has a sequential pipeline:

Entity recognition - regular expressions (file paths, URLs), lexicon (installed commands), preposition framing (“in X” or “on Y”), and (optionally) NLTagger on macOS for parts of speech (POS) recognition
Category matching - Best Matching 25 (BM25) picks the most probable category (Git, ImageMagick, File I/O)
Template match - Score candidates across 167+ templates using BM25, Term Frequency-Inverse Document Frequency (TF-IDF), and NLEmbedding cosine distance on macOS
Slot extraction - entity & regex slot-fill replaces placeholders with actual file names, extension suffixes, URLs, etc
Path resolution - BSD vs GNU adapts commands and flags between macOS (BSD coreutils) and Linux (GNU)
Validation - confirm command existence, bash -n syntax validation, and safety scoring

Testing ShellTalk #

Screenshot of ShellTalk in the browser

You can test ShellTalk yourself on GitHub Pages. This version compiles and optimizes the Swift library into WebAssembly (Wasm) using Binaryen. It works fully offline, although it lacks a few features including command healing–matching output to which commands and versions are installed on your device–and typo correction since NSSpellChecker is only available on macOS. Nonetheless, once the ~45 MB Wasm binary is loaded & cached, you should see near-instant results with safety and confidence scores.

ShellTalk is not perfect. Although it can detect and leverage installed commands, it works best on pre-trained commands bundled in the tool’s corpus. ShellTalk also struggles with ambiguous intent or complex pattern matching for file names, paths, and URLs. But it’s failure modes are deterministic, so they are easy to reproduce and debug. This gives ShellTalk the ability to be quickly and autonomously improved by AI agents.

Limitations #

One of the biggest limitations of ShellTalk is that it intentionally doesn’t synthesize pipelines from user input. The following inputs won’t work:

list swift files, filter by mtime, then wc -l
find all png images then convert jpeg and copy to ~/Downloads

ShellTalk maps one query to one template, so pipes are only used in a stable way for a single intent (counting matches or pbcopy clipboard sink). Generalizing multi-step decomposition would almost certainly require some kind of domain specific language (DSL) or an LLM planner which risks breaking the, “same query, same machine, same result,” contract.

What’s Next? #

ShellTalk is available for free on GitHub, including pre-built binaries for macOS (Universal), Linux (x86_64), and Wasm. The same techniques might work for AppleScript or PowerShell. ShellTalk might prove useful inside of another agentic harness, where it’s deterministic output could spare some tokens.

Building an on-device Swift coding agent using Apple Intelligence

blog@barrasso.me (Tom Barrasso) — Thu, 09 Apr 2026 00:00:00 GMT

I built a fully on-device coding agent called Junco, using Apple Intelligence, the Apple Foundation Model (AFM), in Swift.

Why? To learn, but also to build a tool I want to use myself.

Why call it “Junco?” Because nothing else was named “Junco,” it fits the Swift-related bird theme, and, to be honest, it’s kind of junky compared to Claude Code.

Does Junco work? ~~Kind of!~~ Honestly, not well. It has some very rough edges, but you can try it yourself. Install Junco with a single command:

curl -fsSL https://raw.githubusercontent.com/LastByteLLC/junco/master/install.sh | bash

What is Junco? #

Junco is a free and open-source (MIT-licensed), fully on-device coding agent built in Swift for Swift. It’s a single Mach-O binary that includes a terminal user interface (TUI) and leverages Apple Intelligence’s LanguageModelSession, or other on-device models via Ollama and AnyLanguageModel.

────────────────────────────────────────────────────────────
 junco v0.6.0 — on-device AI coding agent

 Domain: Swift / Apple │ Git: branch: master | 14 files changed
 Dir: ~/Documents/GitHub/junco
 Files: 148 │ Reflections: 61
 Model: Apple Foundation Models (Neural Engine)

 /help for commands │ @file to target │ exit to quit
────────────────────────────────────────────────────────────

Why build Junco? #

I was inspired by Ivan Magda’s swift-claude-code and his 8-part series on developing a Claude Code-like command line interface (CLI) tool in Swift that covers agentic loop, tool calls, subagents, and task planning.

Generally, local models are worse at reasoning, worse at following instructions, more likely to hallucinate, and lack up-to-date world knowledge when compared to state of the art (SOTA) frontier models. Nonetheless, local models like Gemma 4 and Qwen 3.5 continue to get better. Local models have their own benefits like:

Work offline
Better privacy
Lower energy use
No subscription fees

Claude Code launched just over a year ago in February 2025. Now we’re in a Code Overload. I believe local models are on the same, albeit delayed, exponential trajectory.

Why fully local? #

Claude Code and Codex are incredibly powerful, but are limited by cost, privacy, and connectivity. A fully local coding agent has several advantages.

Unit economics: build once, sell many times without the up-front capital for advanced GPUs or operating expense of inference-as-a-service
Trade secret preservation: local inference means intellectual property isn’t revealed to providers like Anthropic or OpenAI
Data privacy: protected health information (PHI), personally-identifiable information (PII), and other sensitive data doesn’t get sent to AI providers

In high-stakes industries like Defense, High-Frequency Trading, and Medical Research, sending source code to a third-party API is often a serious offense. Cloud inference always has a marginal cost, either per token or amortized into a subscription. A local agent could run air-gapped without fear it will train on your trade secrets or leak your .env secrets. Imagine agentic coding on an intercontinental flight without WiFi, or automatic agentic code review on a Self-Hosted GitHub Runner (without paying $15-25 per pull request).

Why not use OpenCode? #

OpenCode is great. I use it to reverse-engineer Android APIs, for JavaScript-to-TypeScript migrations, and much more. However, it’s not designed to work with the AFM’s miniscule 4K context window. In my limited testing, OpenCode with the Apple Foundation Model almost never succeeded without overflowing the context window, and rarely produced valid code.

Junco at a glance #

Screenshot of Junco in Ghostty terminal

Completely free and open source under the MIT license
A single signed & notarized Mach-O binary (~9MB)
Written entirely in Swift 6.2+
Works exclusively on macOS 26+ with Apple Silicon (M1+)
Trained specifically to edit and generate Swift code

Lessons & Limitations #

Apple Intelligence isn’t very intelligent. In my experience, Apple’s 3B model performs worse than just about any similarly-sized model.

So why work with it?

It comes pre-installed. Go to Settings > Apple Intelligence & Siri > Enable, that’s it! This is a huge win for user onboarding.
It’s highly optimized. I get ~40-80+ tokens per second on an M4 Air. The AFM uses less energy and respond faster than most local 2-4B INT4 quantized models in Ollama.
It can be taught. You can train a custom adapter for the AFM, augmenting its style, format, and (to some extent) knowledge.

So what did I learn?

Ask not what your model can do for you #

Apple Foundation Model summarizing Donald Trump

Ask what you can do for your model. Help local models help you: train a text classifier, use named-entity recognition (NER), parse prompts with regular expressions, and search the web. Don’t ask a tiny model to do everything because they’re slow, they hallucinate, and they lack world knowledge.

This screenshot is from maclocal-api, using the Llama.cpp Web UI. Clearly the AFM has a knowledge cutoff before the 2024 US Presidential Election.

Set the model up for success by giving it concise, recent, and relevant information, validate its output, and ask it to try again. For Junco, one of the single most important components was the Compile-Verify-Fix (CVF) Loop. This applies swift-format styles, runs a linter, then executes swiftc -typecheck on all LLM-generated code.

One thing at a time #

Language models, especially small language models (SLMs), get “Lost in the Middle”. The best thing you can do is to have one instruction per prompt, and to put the critical task instruction at the very end.

Claude can handle, “go fix this bug and also check out these logs and then update @README.md,” but SLMs can’t reliably decompose multiple instructions. So give them exactly one task at a time.

Happy little trees #

Both SLMs and Bob Ross love, “Happy Little Trees.” Specially, abstract syntax trees (ASTs) and file trees. These represent token-dense model context that supports cross-file references, symbol extraction, and context compression.

With 1M tokens you might include an entire file plus its call sites. But with 4K tokens, you can only request edits on focused 30 +/- lines of code around the deepest named declaration (i.e. function, class, module) that correspond to a specific error.

Teach a model how to fish #

Give a model a fish and you feed it for one prompt.

Teach a model how to fish and you feed it for a lifetime.

Prompt engineering can only take you so far. For Junco, to generate somewhat-consistently valid and up-to-date Swift code I needed to train a custom model adapter using Low-Rank Adaption (LoRA).

⚠️ Caution: macOS 26 Apple Intelligence Bug

macOS 26.3.1 (likely earlier versions) has a system service bug in TGOnDeviceInferenceProviderService, where an AFM LoRA adapter gets copied into a System Integrity Protection (SIP)-protected location, /private/var/db/AppleIntelligencePlatform/AppModelAssets/, with every instantiation.

This means every time you load an adapter using LanguageModelSession(model: customAdapterModel), you’re copying ~150MB of data that can only be deleted in Recovery Mode. Until Apple fixes this bug, exercise caution when using custom AFM adapters. See Apple Forum #823001 for status and details.

LoRAs are a form of fine tuning where you train a tiny ~60M parameter model. In the case of AFM, you generate a ~160MB .fmadapter file (itself a folder with model weights & metadata). I trained several LoRA iterations for Junco using permissively-licensed code samples, synthetic code, and API signatures. Although initially challenging, the LoRA was the most effective AFM enhancement. It’s difficult to quantize because it’s inherently stochastic, but before the LoRA I almost never got the AFM to generate valid, modern Swift code.

Keep in mind, Apple says you need, “at least 32GB RAM,” to train an adapter. You also need to submit a request form for access, to accept a separate agreement, and to include the com.apple.developer.foundation-model-adapter entitlement in your application. Because this is a com.apple.* restricted namespaced entitlement, you’ll also need to set up a Provisioning Profile, otherwise users will see, “The application “…” can’t be opened.” Apple Mobile File Integrity (AMFI) will log an error like, “Unsatisfied Entitlements: Code has restricted entitlements.”

I managed to train my first adapter on a MacBook Air with 24GB RAM. However, it took ~18 hours on just a single epoch across ~1,000 samples. I’ve since moved to RunPod where I rent an NVIDIA L40S for ~$0.89/hour, and can train several epochs across ~10,000 samples in under an hour! CUDA, Flash Attention, and 48GB VRAM really make a difference.

Fewer guardrails #

Apple wants you to talk nicely to its AI. Don’t swear or get political, otherwise you’ll trigger a guardrail violation! Apple says, “Guardrails aim to block harmful or sensitive content, such as self-harm, violence, and adult materials, from both model input and output.”

In practice, Apple’s guardrails feel too safe. Violations get triggered by aggressive prompts, but also by code, and sometimes mixed-language input. Fortunately, you can turn these guardrails off with SystemLanguageModel(guardrails: .permissiveContentTransformations).

Behind the scenes, Apple uses the MobileAsset framework to load a model with the identifier com.apple.fm.language.instruct_300m.safety. Guardrails uses a 300M-parameter model trained using RL-guidance and human seed data with synthetic expansion to classify intent. permissiveContentTransformations appears to disable these calls and the upstream GenerationError.guardrailViolation error.

Fun fact: Apple’s original codename for the AFM was “Project Greymatter”, which you’ll see signs of in macOS app logs like AFIsDeviceGreymatterEligible.

Count your tokens #

4,096 tokens do not go far when you’re generating code! macOS 26.4+ finally introduces a tokenCount method and contextSize property to avoid context overflows. Presumably, this is in preparation for future model releases where context window size might vary based on device hardware and available memory.

Hopefully future versions of macOS support more features like grammar-constrained decoding. Currently the only output options are maximumResponseTokens and temperature, and the use of @Generable for structured JSON output. These constrain the schema (JSON) but not the syntax.

If you want to go deeper into the technology, check out the Apple Foundation Model Tech Report or poke around /System/Library/PrivateFrameworks/GenerativeModels.framework/ on any Apple Silicon Mac running macOS 26+, although it’s saved in Apple Encrypted Archives (AEA) format.

Stochastic Parroting #

Another weakness of the AFM is stochastic parroting. If you provide exemplar context, you’ll almost certainly get it back verbatim. The best mitigation is to set temperature to 1.0 and do NOT provide example data. If you do not explicitly set the temperature, “the system chooses a reasonable default on your behalf.”

Model of the week #

The past few weeks saw unbelievable development in local models.

Qwen 3.6-35B-A3B
Google’s Gemma 4
PrismML’s 1-Bit Bonsai
Liquid AI’s LFM2.5-350M
Rta AI Lab’s Nandi-Mini-150M

All of these are small enough to run on a MacBook Air. Every week, a new model is released. Technologies like ternary quantization and techniques like TurboQuant compression enable smaller, more capable local models with larger context windows and lower memory usage.

Local models keep getting better. The technology isn’t perfect today, but projects like Junco, Agent!, and iClaw, along with companies like Rig demonstrate that fully-local agents are possible. With the right deterministic harness, proper safeguards, quality training data, and enough investment, local coding agents will get good enough for regular use. It’s only a matter of time.

What’s Next? #

Screenshot of iClaw, an on-device AI agent for macOS

I’m continuing to explore on-device agents with a soon-to-be-released project called iClaw. Many of the same techniques: auto-compacted context, custom LoRA adapter, and MaxEnt tool routing classifier all apply. My goal is to build a safe, helpful, local AI agent. More on iClaw coming soon at geticlaw.com.

Affiliate Disclosure: this article contains affiliate links to RunPod and Claude Code. If you click them and make a purchase, I may receive a small commission at no extra cost to you.

Why Dumbphone Apps Are So Hard to Build

blog@barrasso.me (Tom Barrasso) — Fri, 20 Feb 2026 00:00:00 GMT

On Jose Briones’ Moving Offline Podcast, I talk about PodLP, and how the podcast app for dumbphones was made. We dive into why it’s tough to find your favorite apps on these minimalist devices, and what inspired me to build PodLP during the pandemic. We cover the challenges developers face like small screens, keypad navigation, and platform fragmentation, and discuss why big companies aren’t rushing into the dumbphone movement.

6 lessons from 6 years building software for flip phones

blog@barrasso.me (Tom Barrasso) — Mon, 16 Feb 2026 00:00:00 GMT

I started PodLP in 2020 with no clue it would lead me give talks with 20,000+ aspiring Indian developers and take calls from a New Zealand campground with Bangladesh’s largest telecom company. It’s now 2026, I just launched PodLP for Android, and I still don’t know where it all ends.

Like many, the COVID-19 pandemic gave me sudden free time. Curious to try a “digital detox,” I wanted a flip phone for camping trips. However, the phones then on the market (like the Go Flip 3) didn’t have a podcast app, so I built one.

Fast forward to 2026, I’ve built (and rebuilt) PodLP for three very different platforms: KaiOS, Cloud Phone, and Android. It’s been downloaded over 10 million times across 175+ countries. For many, it was their introduction to podcasts. While its growth has ebbed and flowed, PodLP has proved to be both a successful side hustle and technical playground.

These lessons might not apply to starting a one-person billion-dollar company, but they are relevant for bootstrapping an impactful consumer-facing application without quitting your day job.

1. Leave the crowds #

Podcast apps are a popular genre for burgeoning programmers; building one requires learning networking, parsing, UX, data storage, and media playback. While it’s a valid way to grow as an engineer, most podcast apps never leave GitHub. If you do publish on Google Play or the Apple App Store, yours is often lost in a sea of apps.

PodLP launches on the JioStore

Skip the crowds and launch somewhere you can get organic installs. When I launched PodLP on the JioStore for the JioPhone in India, I saw 100,000+ installs on the first day. Within days there were dozens of YouTube videos featuring PodLP. All with $0 in ad spend.

The challenge is picking the right app store when there are so many. For Android there’s F-Droid (if your app is open source), Huawei AppGallery in China, Tencent Appstore, and Palm Store from Transsion. For browser extensions there’s the Naver Whale Store in Korea and Opera add-ons. For TVs and set-top boxes (STBs) there’s the Jio Developer Program, LG’s Content Store for webOS, and the Foxxum App Store. For games there’s JioGames. For web apps there’s KaiOS and Cloud Phone. Even the Yoto kids speaker has an API! This list isn’t remotely exhaustive.

The lessons you’ll learn measuring engagement, debugging crashes, localizing for diverse markets, generating marketing material, and responding to real user feedback are irreplaceable.

2. The riches are (still) in the niches #

Ask AI to write a KaiOS app, then try to run it on a TCL Flip 4 5G. There’s a good chance it will hallucinate non-existent APIs, and it won’t natively handle directional pad or soft-key navigation unless prompted. You still can’t effectively “vibe code” a decent flip phone app.

In the process of building apps for niche platforms, you’ll learn that documentation lies. Maybe the docs are out of date. Maybe that feature was never built. Maybe its behind an undocumented permission or feature flag. Maybe it only works on one model. You might have to reverse engineer hidden APIs and while you’re looking, stumble upon an “undocumented API” that accidentally grants you root shell access from the browser. These things happen.

This mess is infuriating, but it is exactly why AI has little hope of displacing human labor here. The real world is messy. It requires forging relationships, compliance with arcane rules, and access to hard-to-obtain physical devices.

Despite selling ~150M units, good luck buying a JioPhone in the United States. Yet somehow I built a JioPhone collection including the JioPhone 1, 2 & Next thanks to serendipity, relationships, and perseverance. One from a r/KaiOS Discord member, one via an eBay alert, and one shipped on trust from a translator in India.

Knowing this gives me hope. The future remains full of niches that AI agents can’t or won’t touch because the opportunities are too small, too fragmented, too messy, and too physical.

3. Stick with it #

The full picture requires a focus to ignore “the next thing,” a time horizon in years not minutes, and a psychological “context window” well beyond one million tokens.

Outlining PodLP.com on a whiteboard

It’s easy to get shiny object syndrome. Trends come and go. One minute everyone is “cloud native”, then suddenly everyone is moving back on-prem. IoT, Big Data, and Edge Computing all had their 15 minutes. Now the talk of the Gas Town is AI. Surprisingly few people stick with someone long enough to see it through before getting caught in the next hype cycle.

Because of PodLP and my blog (KaiOS.dev), I was contacted to build Vipaso, a Bluetooth payment app, and support Developer Relations for CloudMosa. I recognize it sounds egotistical, but in some ways, these opportunities were created for me. Had I (or someone like me) not turned up in a search result, these opportunities likely would’ve never appeared on a job board.

You can’t know where it will go unless you stick with it.

4. The power of “Wow!” #

It has never been easier to bake the same cookies everyone else is baking. Using AI, you can generated a polished set of Tailwind landing pages in seconds, but with results that look nearly identical to everyone else.

Not every application needs a custom component library, but don’t overlook the power of “wow!” People remember something distinct, something they never thought was possible. As one Reddit user commented, I’m “surprised you got the native menu row to work on the Kyocera… impressive, it actually feels almost native.”

Spend the extra minute: prompt something novel into existence, preferably not in AI purple.

5. Technical lesson: memory matters #

OutOfMemoryError from PodLP on the LG Wine 2

Now for some nerd talk. Most of what I’ve built is I/O bound. For flip phones, a major hurdle is out-of-memory (OOM) errors. I soon discovered how big podcasts get. Take Blue Wire’s Pack-a-Day Podcast as an example.

The RSS feed on Simplecast is 12.97MB of XML!
The artwork is a 3000x3000 PNG totalling 251KB
There are 4,275+ episodes averaging ~56MB

Now consider the build.prop from my LG Wine 2 (2020), a flip phone with 1GB RAM running Android Go.

[dalvik.vm.heapgrowthlimit]: [128m]
[dalvik.vm.heapsize]: [36m]

With a 36MB heap limit, every byte counts. I probably should have ignored the LG Wine 2, but I wanted PodLP to work well on low-end phones. I implemented:

Chunking & streaming. I moved away from JSON.parse or responseXML, which loads the whole document into memory. Instead, I used stream parsing and tools like Kotlin Flows. For audio I used Range requests, chunking, or streaming (based on what’s available).
Don’t be transparent. Images are collections of pixels. Android’s default ARGB_8888 format uses 32 bits per pixel, but, flip phones don’t exactly have Retina displays. Switching to RGB_565 uses only 16 bits, doubling the number of images I can display.
Take control. On native platforms like Android, I switched from the default to OkHttpDataSource to share the same connect and thread pools, add interceptors for Brotli and GZIP compression, support HTTP/2 multiplexing, and have more consistent buffer size control.

In the end, getting PodLP to work on low-end phones like the LG Wine 2 meant it ran faster on newer devices with better hardware like the Sonim XP3+ and Kyocera DuraXV.

6. It only gets easier #

When I started PodLP, podcast APIs were paid. I built my own directory, and now there’s a free and open source Podcast Index.

When I started, low-cost distributed databases didn’t exist. I made my own SQLite on Elastic File Service (EFS) that supported millions of users for pennies per month. Now services like Amazon Aurora Serverless and Cloudflare D1 are easy to use and scale to zero.

My first Cloud Phone was a Nokia 110 4G with a QQVGA (128x160) screen using a 4G SIM card from Red Pocket. I would debug remotely using tools like RemoteJS. Now there’s a Cloud Phone Simulator that runs a full developer console in your browser.

In 2024, I wrote the first–and only–guide to publishing on the JioStore for JioPhone. After having nearly a dozen builds rejected were the complete set of rules and requirements shared with me. Things like using a four digit version code, supporting IPv6-only networks (without NAT64), and displaying an exit confirmation dialog.

As time moves on, eventually someone else will share your problem, and eventually someone else fix it. Each problem could itself become a new product or pivot. Either way, you can make it easier for someone else, or someone else can make it easier for you. But it only gets easier.

Closing thoughts #

Marked Access Ends Here

I find writing creates clarity. This article scratches the surface of a journey that’s taken me–and continues to take me–around the world. It’s taught me the immense value of the small, the fragmented, and the persistent.

Quickly reverse engineer hidden Android APIs with Gemini and OpenCode

blog@barrasso.me (Tom Barrasso) — Sun, 11 Jan 2026 00:00:00 GMT

Why Reverse Engineer an APK? #

In the early days of Android more than a decade ago, I built UI customization apps like StatusBar+, ChargeBar, and Noyze. Fragmentation was a big problem. This was long before Material UI was released in 2014, and well before Google certified original equipment manufacturer (OEMs) through Play Protect in 2017.

To build apps that looked and worked well on Samsung’s TouchWiz, Xiaomi’s MIUI, and HTC’s Sense, you needed to know how to reverse engineer preinstalled APKs and the SystemUI to understand what modifications had been made on each device. At runtime, this looked like a lot of Java reflection checking for the availability of hidden APIs. Android Interface Definition Language (AIDL) files were reconstructed and imported from disassembled APKs to call into device-specific APIs and offer better features.

This is an example of code I wrote in 2014 for Noyze used to call into AudioFlinger to determine the available volume streams and the associated number of steps. Some devices let you adjust in steps as few as 5, while others offered more gradations as high as 15. Many of these variations weren’t yet standardized into higher-level APIs that developers could query.

package me.barrasso.android.volume.media;

/**
 * Proxy to safely access android.media.IAudioFlinger methods.
 */
public class AudioFlingerProxy {
 // Values from IAudioFlinger.cpp
 public static final int CREATE_TRACK = IBinder.FIRST_CALL_TRANSACTION; // 1
 public static final int OPEN_RECORD = CREATE_TRACK + 1; // 2
 public static final int SAMPLE_RATE = OPEN_RECORD + 1; // 3
 public static final int CHANNEL_COUNT = SAMPLE_RATE + 1; // 4
 public static final int FORMAT = CHANNEL_COUNT + 1; // 5
 public static final int FRAME_COUNT = FORMAT + 1; // 6
 public static final int LATENCY = FRAME_COUNT + 1; // 7
 public static final int SET_MASTER_VOLUME = LATENCY + 1; // 8
 public static final int SET_MASTER_MUTE = SET_MASTER_VOLUME + 1; // 9
 public static final int MASTER_VOLUME = SET_MASTER_MUTE + 1; // 10
 public static final int MASTER_MUTE = MASTER_VOLUME + 1; // 11
 public static final int SET_STREAM_VOLUME = MASTER_MUTE + 1; // 12
 public static final int SET_STREAM_MUTE = SET_STREAM_VOLUME + 1; // 13
 public static final int STREAM_VOLUME = SET_STREAM_MUTE + 1; // 14
 public static final int STREAM_MUTE = STREAM_VOLUME + 1; // 15
 public static final int SET_MODE = STREAM_MUTE + 1; // 16

 public static final int DEFAULT = -1;
 public static final int VOICE_CALL = 0;
 public static final int SYSTEM = 1;
 public static final int RING = 2;
 public static final int MUSIC = 3;
 public static final int ALARM = 4;
 public static final int NOTIFICATION = 5;
 public static final int BLUETOOTH_SCO = 6;
 public static final int ENFORCED_AUDIBLE = 7;
 public static final int DTMF = 8;
 public static final int TTS = 9;

 // Values from errno.h
 public static final int NO_ERROR = 0;
 public static final int UNKNOWN_TRANSACTION = -74; // -EBADMSG;
 public static final int BAD_VALUE = -22; // -EINVAL;
 public static final int PERMISSION_DENIED = -1; // -EPERM;

 public static final int CALIBRATION_ERROR = -64;

 private static final String FLINGER_SERVICE = "media.audio_flinger";

 private final String mInterfaceDescriptor;
 private final IBinder mAudioFlinger;

 private final SparseArray<SparseArray<Float>> mStreamStepMap = new SparseArray<SparseArray<Float>>();

 public AudioFlingerProxy() {
 mAudioFlinger = ReflectionUtils.getServiceManager(FLINGER_SERVICE);

 String mID = "";
 {
 try {
 mID = mAudioFlinger.getInterfaceDescriptor();
 } catch (RemoteException e) {
 mID = "";
 }
 }
 mInterfaceDescriptor = mID;
 }

 public boolean isCalibrated(int stream) {
 SparseArray<Float> map = mStreamStepMap.get(stream);
 return (map != null && map.size() >= 2);
 }

 public void mapStreamIndex(int stream, int index) {
 SparseArray<Float> map = mStreamStepMap.get(stream);
 if (null == map) map = new SparseArray<Float>();

 try {
 float value = getStreamVolume(stream);
 map.put(index, value);
 } catch (RemoteException re) { }

 mStreamStepMap.put(stream, map);
 }

 /**
 * Set the volume_3 of a calibrated stream.
 * @see {@link #setStreamVolume(int, float)}
 * @throws RemoteException
 */
 public int adjustStreamVolume(int stream, int direction, int index, int max) throws RemoteException {
 if (null == mAudioFlinger || TextUtils.isEmpty(mInterfaceDescriptor) || !isCalibrated(stream)) {
 return BAD_VALUE;
 }

 float value = getStreamVolume(stream);
 float increment = getStreamIncrement(stream);

 float newValue = value;
 switch (direction) {
 case AudioManager.ADJUST_LOWER:
 newValue -= increment;
 case AudioManager.ADJUST_RAISE:
 newValue += increment;
 }
 newValue = Math.max(0, Math.min(newValue, max * increment));

 return setStreamVolume(stream, newValue);
 }

 // change this value to change volume_3 scaling
 protected static float dBPerStep = 0.5f;
 // shouldn't need to touch these
 protected static float dBConvert = -dBPerStep * 2.302585093f / 20.0f;
 protected static float dBConvertInverse = 1.0f / dBConvert;

 protected static float linearToLog(int volume) {
 if (volume == 0) return 0.0f;
 return (float) Math.exp(100 - volume * dBConvert);
 }

 protected static int logToLinear(float volume) {
 if (volume == 0.0f) return 0;
 return (int) (100 - (dBConvertInverse * Math.log(volume) + 0.5));
 }

 protected static float computeVolume(int index, int max) {
 int mIndexMin = 0;
 int volInt = (100 * (index - mIndexMin)) / (max - mIndexMin);
 return linearToLog(volInt);
 }

 protected float getStreamIncrement(int stream) throws RemoteException {
 // Figure out what the increment is.
 SparseArray<Float> map = mStreamStepMap.get(stream);
 int indexOne = map.keyAt(0);
 int indexTwo = map.keyAt(1);
 float valueOne = map.get(indexOne);
 float valueTwo = map.get(indexTwo);

 return Math.abs(valueTwo - valueOne) /
 Math.abs(indexTwo - indexOne);
 }

 public int getStreamIndex(int stream) throws RemoteException {
 if (null == mAudioFlinger || TextUtils.isEmpty(mInterfaceDescriptor) || !isCalibrated(stream)) {
 return BAD_VALUE;
 }

 float value = getStreamVolume(stream);
 float increment = getStreamIncrement(stream);

 return Math.round(value / increment);
 }

 public int setStreamVolume(int stream, float value) throws RemoteException {
 if (null == mAudioFlinger || TextUtils.isEmpty(mInterfaceDescriptor)) {
 return BAD_VALUE;
 }

 Parcel data = Parcel.obtain();
 Parcel reply = Parcel.obtain();
 data.writeInterfaceToken(mInterfaceDescriptor);
 data.writeInt(stream);
 data.writeFloat(value);
 mAudioFlinger.transact(SET_STREAM_VOLUME, data, reply, 0);
 return reply.readInt();
 }

 public float getStreamVolume(int stream) throws RemoteException {
 if (null == mAudioFlinger || TextUtils.isEmpty(mInterfaceDescriptor)) {
 return BAD_VALUE;
 }

 Parcel data = Parcel.obtain();
 Parcel reply = Parcel.obtain();
 data.writeInterfaceToken(mInterfaceDescriptor);
 data.writeInt(stream);
 mAudioFlinger.transact(STREAM_VOLUME, data, reply, 0);
 float ret = Float.intBitsToFloat(reply.readInt());
 return ret;
 }
}

Reverse Engineering Tools #

There are tons of tools for reverse engineering Android apps. Back then, I primarily used JD-GUI, JADX, Apktool. Apktool is a powerful Android disassembler that rips apart an Android Package Kit (APK) file, itself just a ZIP archive, into its constituent parts. Java/ Kotlin code built for the Android Runtime (ART) is compiled into DEX bytecode, which can be disassembled into Smali, a human-readable text format that represents the complete structure of a Dex Virtual Machine (VM) class including all of its instructions.

In 2014, whenever these tools failed to disassemble certain classes I would manually reconstruct them through some informal deduction. I’d look at the various call sites, interface definitions, and available resources to mentally re-assemble API signatures. Then I’d run some reflection inside of an app to test what was and wasn’t available. Some APIs were restricted to certain packages, permissions, or required proprietary features.

Why Now? #

In 2026, I find myself in the same situation as I was in 2014. I’m building my podcast app, PodLP, for Android flip phones and once again I am running into inconsistent behaviors. Some devices (i.e. Kyocera, Sonim, and Ketai) have custom APIs to control soft keys, some have special features like Push-to-Talk (PTT) and SOS hot keys, and some offer an Eco mode that interferes with foreground services and network access when the clamshell is closed or screen dims.

Because I’m targeting a niche set of highly-fragmented devices, once again I need to reverse engineer non-standard APIs in order to offer a high-quality, consistent experience across a large number of non-certified devices.

Reverse Engineering in OpenCode #

I’m pleasantly surprised that in order to reconstruct an APK (or at least several relevant APIs), there’s virtually no prompt engineering needed.

First I enable developer options via Settings > About >, then click Build 7 times. Next, I query the installed packages

adb shell cmd package list packages

On my Kyocera DuraXV Extreme E4810 this returned:

jp.kyocera.hiddendebug
jp.kyocera.kyocerahome
com.android.cts.priv.ctsshim
com.vzw.apnlib
com.android.internal.display.cutout.emulation.corner
com.android.internal.display.cutout.emulation.double
com.android.providers.telephony
com.kyocera.diagnostic
com.verizon.mips.services
com.android.providers.calendar
com.android.providers.media
com.android.wallpapercropper
com.quicinc.cne.CNEService
jp.kyocera.filemanager.launcher
com.kyocera.flashlight
com.android.documentsui
com.android.externalstorage
com.android.frameworks.overlay
com.android.htmlviewer
com.android.companiondevicemanager
com.verizon.obdm_permissions
com.android.mms.service
com.kyocera.calculator2
com.android.providers.downloads
jp.kyocera.gallery.launcher
com.mobisystems.office.kyocera
com.qualcomm.qti.telephonyservice
com.kyocera.labtest
com.android.browser
com.vcast.mediamanager
com.android.defcontainer
jp.kyocera.oemsetupwizard
com.android.providers.downloads.ui
com.android.pacprocessor
com.android.simappdialog
jp.kyocera.datafolder
com.android.internal.display.cutout.emulation.tall
com.android.certinstaller
jp.kyocera.corp.manager
com.android.carrierconfig
com.google.android.marvin.talkback
jp.kyocera.kchandlenv
com.qti.qualcomm.datastatusnotification
jp.kyocera.LocationConsentApp
android
com.android.contacts
com.android.egg
com.android.mms
com.android.mtp
com.android.stk
com.android.backupconfirm
jp.kyocera.ecomode
com.kyocera.telephony
jp.kyocera.settings.nfp
com.android.provision
org.codeaurora.ims
com.android.statementservice
com.verizon.bootstrapclient
com.android.settings.intelligence
com.android.calendar
com.android.systemui.theme.dark
com.kyocera.kcPhoneService
jp.kyocera.WebViewer
jp.kyocera.kc_soundrecorder
com.qualcomm.qti.dynamicddsservice
com.qualcomm.qcrilmsgtunnel
com.android.providers.settings
jp.kyocera.kdfs
jp.kyocera.kerr
jp.kyocera.memo
com.android.sharedstoragebackup
com.android.printspooler
com.android.dreams.basic
com.android.webview
com.kyocera.kcTelecommService
com.android.inputdevices
jp.kyocera.selfprovisioning
jp.kyocera.customizekey
com.android.bips
jp.kyocera.providers.memo
com.android.musicfx
com.kyocera.worldclock
com.ffm.kyocera
com.kyocera.voicerecognition
jp.kyocera.poweronactivation
com.android.cellbroadcastreceiver
android.ext.shared
com.android.onetimeinitializer
com.skyhookwireless.provider
com.kyocera.telephonyextra
com.android.server.telecom
com.android.keychain
jp.kyocera.vzwextension.service
com.kyocera.stopwatch
com.android.printservice.recommendation
com.android.dialer
android.ext.services
com.android.calllogbackup
com.android.packageinstaller
com.android.carrierdefaultapp
com.svox.pico
com.android.proxyhandler
jp.kyocera.kitting
com.android.managedprovisioning
com.kyocera.wifiautoactivate
jp.kyocera.kc_fmradio
jp.kyocera.batterycare
com.kyocera.mediumkey
com.android.server.telecom.overlay
com.kyocera.PcoStatusReceiver
jp.kyocera.kcPhoneSettings
com.android.storagemanager
com.android.bookmarkprovider
com.android.settings
com.kyocera.calendar.localaccount
com.verizon.obdm
com.qualcomm.location
com.android.cts.ctsshim
com.kyocera.alarm
com.kyocera.omadm
com.kyocera.timer
com.android.vpndialogs
com.kyocera.musicplayer
com.android.email
com.android.phone
com.android.shell
com.android.wallpaperbackup
com.android.providers.blockednumber
com.android.providers.userdictionary
com.android.emergency
jp.kyocera.providers.settings
com.android.location.fused
com.android.systemui
jp.kyocera.devicecontrol
com.android.exchange
com.android.bluetoothmidiservice
com.qualcomm.qti.poweroffalarm
jp.kyocera.kclightsservice
com.kyocera.apnsetting
com.android.traceur
jp.kyocera.thermalmonitor
com.android.bluetooth
com.qualcomm.timeservice
com.qualcomm.atfwd
com.android.providers.contacts
com.android.captiveportallogin
com.verizon.mdm.xvlte
com.verizon.pushtotalkplus
jp.kyocera.sub.kitting

At this point, I can use my intuition or defer to an LLM which packages to search. I’ll pull those packages to my computer and run Apktool to disassemble.

#!/usr/bin/env bash

if [ "$#" -eq 0 ]; then
 echo "Usage: $0 <package.name> [package.name ...]"
 exit 1
fi

OUT_DIR="decompiled"
APK_DIR="apks"

mkdir -p "$OUT_DIR" "$APK_DIR"

for pkg in "$@"; do
 # Query APK paths from device
 paths=$(adb shell pm path "$pkg" | sed 's/^package://')

 if [ -z "$paths" ]; then
 echo " ! Package not found: $pkg"
 continue
 fi

 pkg_apk_dir="$APK_DIR/$pkg"
 mkdir -p "$pkg_apk_dir"

 # Pull base + split APKs
 for path in $paths; do
 apk_name=$(basename "$path")
 echo " Pulling $apk_name"
 adb pull "$path" "$pkg_apk_dir/$apk_name"
 done

 # Prefer base.apk for apktool
 base_apk=$(ls "$pkg_apk_dir"/base*.apk 2>/dev/null | head -n 1)

 # Fallback for legacy single-apk installs
 if [ -z "$base_apk" ]; then
 base_apk=$(ls "$pkg_apk_dir"/*.apk 2>/dev/null | head -n 1)
 fi

 if [ -n "$base_apk" ]; then
 echo " Decompiling $(basename "$base_apk")"
 apktool d -f "$base_apk" -o "$OUT_DIR/$pkg"
 else
 echo " ! No APK found to decompile for $pkg"
 fi
done

From this point, I’ll grep the resulting Smali for interfaces I’m interested in. Here’s an snippet of an Activity in the Voice Recognition app that calls into jp/kyocera/kcfp/util/KCfpSoftkeyGuide which is a strong candidate.

.class public Lcom/kyocera/voicerecognition/TopHelpActivity;
.super Landroid/app/Activity;
.source "TopHelpActivity.java"

# static fields
.field public static final LOGTAG:Ljava/lang/String;


# instance fields
.field private final closeAppTask:Ljava/lang/Runnable;

.field private final handler:Landroid/os/Handler;

.field private mEngine:Lcom/kyocera/voicerecognition/ReadoutText;

.method protected onCreate(Landroid/os/Bundle;)V
 .locals 3

 .line 32
 invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V

 .line 33
 sget-object p1, Lcom/kyocera/voicerecognition/TopHelpActivity;->LOGTAG:Ljava/lang/String;

 const-string v0, "onCreate[in]"

 // ...

 .line 38
 invoke-static {}, Ljp/kyocera/kcfp/util/KCfpWidgetUtil;->getInstance()Ljp/kyocera/kcfp/util/KCfpWidgetUtil;

 move-result-object v0

 invoke-virtual {p0}, Lcom/kyocera/voicerecognition/TopHelpActivity;->getActionBar()Landroid/app/ActionBar;

 move-result-object v1

 const/4 v2, 0x0

 invoke-virtual {v0, v1, v2}, Ljp/kyocera/kcfp/util/KCfpWidgetUtil;->setDisplayShowOverflowMenuButtonEnabled(Landroid/app/ActionBar;Z)V

 const v0, 0x7f0d009f

 .line 39
 invoke-virtual {p0, v0}, Lcom/kyocera/voicerecognition/TopHelpActivity;->getString(I)Ljava/lang/String;

 move-result-object v0

 .line 40
 invoke-virtual {p0}, Lcom/kyocera/voicerecognition/TopHelpActivity;->getWindow()Landroid/view/Window;

 move-result-object v1

 invoke-static {v1}, Ljp/kyocera/kcfp/util/KCfpSoftkeyGuide;->getSoftkeyGuide(Landroid/view/Window;)Ljp/kyocera/kcfp/util/KCfpSoftkeyGuide;

 move-result-object v1

 if-eqz v1, :cond_0

 .line 43
 invoke-virtual {v1, v2, v0}, Ljp/kyocera/kcfp/util/KCfpSoftkeyGuide;->setText(ILjava/lang/CharSequence;)V

 .line 44
 invoke-virtual {v1}, Ljp/kyocera/kcfp/util/KCfpSoftkeyGuide;->invalidate()V

 :cond_0
 const v0, 0x7f080054

 .line 47
 invoke-virtual {p0, v0}, Lcom/kyocera/voicerecognition/TopHelpActivity;->findViewById(I)Landroid/view/View;

 move-result-object v0

 check-cast v0, Landroid/widget/TextView;

 .line 48
 invoke-virtual {v0, p1}, Landroid/widget/TextView;->setText(I)V

 const p1, 0x7f080053

 .line 49
 invoke-virtual {p0, p1}, Lcom/kyocera/voicerecognition/TopHelpActivity;->findViewById(I)Landroid/view/View;

 move-result-object p1

 check-cast p1, Landroid/widget/TextView;

 const/16 v0, 0x8

 .line 50
 invoke-virtual {p1, v0}, Landroid/widget/TextView;->setVisibility(I)V

 .line 51
 sget-object p1, Lcom/kyocera/voicerecognition/TopHelpActivity;->LOGTAG:Ljava/lang/String;

 const-string v0, "onCreate[out]"

 invoke-static {p1, v0}, Lcom/kyocera/voicerecognition/util/LogUtils;->d(Ljava/lang/String;Ljava/lang/String;)V

 return-void
.end method

Then with a single prompt in OpenCode, I have a Java class! I’m using Gemini 3 Flash, which I’ve generally found to be the most effective model when working with Android. Plus Anthropic is sadly blocking Claude subscriptions inside OpenCode.







 █▀▀█ █▀▀█ █▀▀█ █▀▀▄ █▀▀▀ █▀▀█ █▀▀█ █▀▀█
 █░░█ █░░█ █▀▀▀ █░░█ █░░░ █░░█ █░░█ █▀▀▀
 ▀▀▀▀ █▀▀▀ ▀▀▀▀ ▀ ▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀▀


 ┃
 ┃ Reassemble the @smali/com/kyocera/voicerecognition/TopHelpActivity.
 ┃ smali Smali into its original Java class, with a focus on
 ┃ reconstructing APIs it calls into from the 'jp.kyocera.kcfp` package
 ┃
 ┃ Build Gemini 3 Flash Preview Google
 ╹▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
 tab switch agent ctrl+p commands






 ~/Kyocera/decompiled/VoiceRecognition 1.1.13

After a few seconds and 47,573 tokens (~$0.05), OpenCode wrote the full Java class and specifically re-constructed the interfaces to the APIs that I’m interested in.

Locating Dependent Smali Files

I’m now focusing on locating the necessary smali files for the jp.kyocera.kcfp classes. Specifically, I need the files for the package structure to ensure proper reconstruction of the dependent classes. I plan to begin by searching for the jp/kyocera/kcfp directory. This should provide the information needed for accurate reassembly.

I’ve analyzed the TopHelpActivity.smali file. To accurately reassemble it and reconstruct the jp.kyocera.kcfp APIs, I’ll first locate and examine the relevant smali files for the external libraries and inner classes.

tool_call: glob for pattern '*/jp/kyocera/kcfp/util/.smali'

tool_call: glob for pattern '*/com/kyocera/voicerecognition/TopHelpActivity$.smali'

tool_call: glob for pattern '**/com/kyocera/voicerecognition/ReadoutText.smali'

tool_call: glob for pattern '**/com/kyocera/voicerecognition/VoiceRecognition.smali'

tool_call: glob for pattern '**/com/kyocera/voicerecognition/util/LogUtils.smali'

✱ Glob “**/jp/kyocera/kcfp/util/*.smali”

✱ Glob “**/com/kyocera/voicerecognition/TopHelpActivity$*.smali” (3 matches)

✱ Glob “**/com/kyocera/voicerecognition/ReadoutText.smali” (1 matches)

✱ Glob “**/com/kyocera/voicerecognition/VoiceRecognition.smali” (1 matches)

✱ Glob “**/com/kyocera/voicerecognition/util/LogUtils.smali” (1 matches)

Here’s a snippet from the resulting Java file.

package com.kyocera.voicerecognition;

// ...
import jp.kyocera.kcfp.util.KCfpSoftkeyGuide;
import jp.kyocera.kcfp.util.KCfpWidgetUtil;

/**
 * Activity for displaying top-level help information with voice readout.
 */
public class TopHelpActivity extends Activity {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);

 setContentView(0x7f0a0023); // R.layout.top_help_activity
 setTitle(0x7f0d006e); // R.string.help_title
 mEngine = ReadoutText.getInstance();

 // Initial voice readout: "Help Title, Help Description"
 String speakText = getString(0x7f0d006e) + "," + getString(0x7f0d006d);
 mEngine.speak(speakText, "INIT");

 // Kyocera Framework: Disable overflow menu button in ActionBar
 KCfpWidgetUtil.getInstance().setDisplayShowOverflowMenuButtonEnabled(getActionBar(), false);

 // Kyocera Framework: Set softkey guide text
 String softkeyText = getString(0x7f0d009f); // R.string.softkey_close
 KCfpSoftkeyGuide guide = KCfpSoftkeyGuide.getSoftkeyGuide(getWindow());
 if (guide != null) {
 guide.setText(0, softkeyText);
 guide.invalidate();
 }

 // Set UI text
 TextView titleView = (TextView) findViewById(0x7f080054); // R.id.help_title
 titleView.setText(0x7f0d006e);
 TextView subtitleView = (TextView) findViewById(0x7f080053); // R.id.help_subtitle
 subtitleView.setVisibility(8); // GONE
 }

As well as the soft key API that I care about:

package jp.kyocera.kcfp.util;
import android.view.Window;

/**
 * Reconstructed utility for managing softkey guides on Kyocera devices.
 */
public class KCfpSoftkeyGuide {

 public static KCfpSoftkeyGuide getSoftkeyGuide(Window window) {
 // Implementation provided by Kyocera KCFP framework
 }

 /**
 * Sets the text for a specific softkey.
 * @param index The index of the softkey (e.g., 0 for left/center softkey).
 * @param text The text to display.
 */
 public void setText(int index, CharSequence text) {
 // Implementation provided by Kyocera KCFP framework
 }

 /**
 * Invalidates the guide view to trigger a redraw.
 */
 public void invalidate() {
 // Implementation provided by Kyocera KCFP framework
 }

 // ...
}

It turns out this API was already documented on r/flipphones as well as the timeweb blog (in Russian). Nonetheless, it illustrates just how quickly an LLM can reconstruct Java code from Smali. With a more thorough prompt, this could be applied to an entire APK, properly map resource IDs, and even apply reasonable variable names to code minified using Proguard!

After a bit more searching, I was able to reconsruct the entire API including the setSoftkeyEventListener method and corresponding listener. Before integrating these APIs into PodLP, clicking the physical volume keys would trigger the soft key bar to show and not hide with the system dialog. After integration, the app feels more native and no longer has the previous quirks.

Part 2. Sonim and Beyond #

PodLP on the Sonim XP3+ (left) and Kyocera DuraXV (right)

Thanks to the folks on the JTech Forum and for several newly-acquired devices on eBay, I’ve been able to investigate the firmware on more models. For instance, on the Sonim XP3+ XP3900 soft keys are handled in a completely different way.

Unlike Kyocera, there are three soft keys (left, middle, and right). Soft middle is a separate key from Enter or DPAD_CENTER. The soft key UI cannot be hidden, and menu items can only be Strings (no Drawables). Setting soft keys is easy:

val softBarIntent = Intent("android.intent.action.CHANGE_NAV_BAR").apply {
 putExtra("left", "Menu")
 putExtra("center", "Select")
 putExtra("right", "Back")
 putExtra("from_package", context.packageName)
}

context.sendBroadcast(softBarIntent)

Unfortunately, it’s not possible to detect this Intent’s receiver with packageManager.queryBroadcastReceivers because it’s registered dynamically inside SystemUI using the centralized BroadcastDispatcher. There is no way to know whether the Intent was received and the UI updated.

01-21 17:29:32.806 7704 7713 W dex2oat32: Accessing hidden method Landroid/content/Context;->isUiContext()Z (blacklist, linking, denied)

I’ve also been experimenting with other hidden APIs. In this instance, access via Android X or some compatability library was blocked from calling Context.isUiContext. Because the Sonim XP3+ runs Android 11 (the Kyocera DuraXV runs the much older Android 8), I’ve had to use HiddenApiBypass to circumvent the Android 9+ restrictions on non-SDK interfaces. Fortunately, LSPass works well on the Sonim XP3+ so I’ve been able to continue experimenting.

Conclusion #

Using Gemini via OpenCode for reverse engineering hidden Android APIs is much more efficient than doing it by hand. As I acquire more phone models, I’ll expand this analysis to better integrate into these fragmented feature phones. I’m also exploring other uses of Gemini & OpenCode for Android development including:

Constructing utility classes leveraging reflection to call hidden APIs
Integrating hidden API utilities into my application’s lifecycle
Generating Vector Drawables and adaptive icons from Scalable Vector Graphics (SVG) files
Writing Proguard rules to optimize release builds

Testing on physical devices is still critical, but I wish I had tools like Gemini and OpenCode back in 2012-2015 when I was actively reverse engineering many flagship Android phones for fun and profit.

Migrating PodLP from JavaScript to TypeScript using OpenCode

blog@barrasso.me (Tom Barrasso) — Mon, 22 Dec 2025 00:00:00 GMT

At a Glance #

I migrated PodLP, my podcast app for KaiOS, from JavaScript to TypeScript.

Scale. ~35,000 lines of code (LOC) across 160 JavaScript files, 67 Svelte components, and 28 JSON translation dictionaries
Cost. $43 using $300 free credit for new Google Cloud customers
Time. Two half days of background tasks, primarily baking cookies and working on other projects
Impact. A codebase that’s completely migrated to TypeScript
What didn’t work? Attempting a one-shot conversion
What did work? Multiple well-scoped subagents and some patience

Background and Motivation #

I’ve maintained PodLP for 5+ years. As it grew, it became more complex and honestly a bit messy. It eventually morphed into a monorepo with several front-end versions: the original for KaiOS, one for the JioPhone (India), and one for Cloud Phone.

Moreover, when I started PodLP, I knew nothing about podcatchers or podcast indexing. I also had no experience with KaiOS or it’s many quirks and undocumented APIs. Iteratively over several years, the app grew in size and complexity. Yet I still generated builds (ZIP files) locally on my M1 MacBook Air and uploaded them manually to the KaiStore.

I tried to keep up-to-date with processes and dependencies. I upgraded PodLP from Svelte 3 to Svelte 4, I rewrote offline downloads to used chunked streams (moz-chunked-arraybuffer) written not to IndexedDB but instead to DeviceStorage, I added support for KaiOS 3.0 and I migrated PodLP’s back-end to the Podcast Index.

Although there are tools like jscodeshift and sv migrate, large-scale refactoring of 200+ files and 30,000+ lines without ready-made scripts was too much time and effort to justify. Inspired by Simon Willison’s port of JustHTML from Python to JavaScript, I decided to try a similar agentic approach.

But First, A Types Library #

Many footpaths to choose on Mt. Watatic

Before beginning this migration, I knew the biggest challenge would be the lack of type definitions for the many non-standard KaiOS APIs. Fortunately, large parts of KaiOS are built on top of Firefox OS (aka Boot2Gecko or B2G) and are open source. This informed many of my articles on KaiOS.dev, since I often needed to grep the codebase to uncover implementation details or edge cases.

Many KaiOS APIs are written in WebIDL (Web Interface Description Language), which is very similar to TypeScript type declarations (.d.ts files).

Consider MozWakeLock.webidl:

[Pref="dom.wakelock.enabled", Func="Navigator::HasWakeLockSupport"]
interface MozWakeLock
{
 readonly attribute DOMString topic;

 /**
 * Release the wake lock.
 * @throw NS_ERROR_DOM_INVALID_STATE_ERR if already unlocked.
 */
 [Throws]
 void unlock();
};

In TypeScript (see moz-wake-lock.d.ts), the interface looks like:

/**
 * @preference dom.wakelock.enabled
 * Represents a lock that prevents the device from entering sleep mode.
 */
export interface MozWakeLock {
 readonly topic: string;

 /**
 * Releases the wake lock.
 * @throws
 */
 unlock(): void;
}

For clients like Vipaso I’ve done this conversion by hand. It’s straightforward but tedious. So I decided to see if I could do this at scale using OpenCode. From the onset, my approach looked like:

Prompt through a few examples and summarize conversion steps
Define a purpose-limited subagent for conversion
Draft a set of quality & validation steps (i.e. files validates with tsc, formatted using prettier, etc)

I then had Gemini explore the codebase and decompose the process into a task list and begin conversion with the following agents:

Project Manager: oversaw the process and provided status reports with checklists of tasks pending and completed; handled retries when issues were uncovered
Converter: a narrowly-scoped subagent for converting WebIDL to TypeScript type declarations with clear instructions on converting types and handling annotations
Documenter: a subagent to copy WebIDL comments and annotations into consistently-formatted TSDoc comments with tags like @see for documentation links and @throws for errors

The entire process was remarkably smooth. In a few hours, I had dozens of type definitions spanning hundreds of interfaces. I then had the default Build agent write a set of tests and a GitHub Action to deploy to NPM, and my new kaios-types library for KaiOS 2.5 was ready to use! I considered publishing on DefinitelyTypes, which runs the @types/ NPM namespace, but figured as a first pass there would be many changes needed. Once it’s more complete (esp. including KaiOS 3.0+ APIs) and tested in the real-world, it may make sense to bring to DefinitelyTyped.

Aside: `webidl2ts` #

I’m aware that there are several libraries like webidl2ts that convert WebIDL to TypeScript like webidl2. In the past, I’ve tried this approach but ran into several issues.

Not all KaiOS APIs are defined in WebIDL files
Some WebIDL files that don’t originate from Boot2Gecko are not open source
Parsers operate file-by-file without an understanding of module resolution
Parsers often fail for complex WebIDL files with inheritance or incomplete but similar types

KaiOS can be a mess. For example, asynchronous programming includes DOMRequest callbacks (KaiOS 2.5 only), Promises (partially supported on KaiOS 2.5 without the finally method), and the async keyword on KaiOS 3.0+. I probably could have taken a hybrid approach allowing an agent to make a tool call to webidl2, but I didn’t find it necessary. Plus, it would have roughly doubled input token usage to send both a .webidl and .d.ts file in the context for each request. Perhaps a future attempt would use AI to write a custom parser using webidl2 tested specifically against Firefox and KaiOS.

Now With More Logic #

Given how easy it was to create kaios-types, I decided to replicate the success with a JS to TS conversion for PodLP. This time, I asked Claude to come up with a plan. Here is an excerpt:

# TypeScript Migration Plan - Fast Track

## Overview

Migrate JavaScript files to TypeScript using pragmatic typing with liberal `any` usage for speed. Testing on both KaiOS 2.5 and 3.0 devices available.

## Strategy

- **Speed First**: Use `any` liberally where KaiOS APIs lack complete type definitions
- **Follow Patterns**: Match existing migrated files' typing approach
- **Build Validation**: Verify TypeScript compiles and Babel transpiles correctly
- **No Babel Changes**: Preserve existing transpilation configuration

## Migration Workflow Per File

1. **Rename**: `mv file.js file.ts`
2. **Add Types**:
 - Function parameters: `function foo(param: type): returnType`
 - Use `any` for complex KaiOS APIs
 - Use `any` for Svelte stores unless trivial
3. **Import Types**: Add `import type` for type-only imports
4. **Build**: `npm run build` (fixes Babel issues)
5. **Type Check**: `npx tsc --noEmit` (optional, for catching errors)
6. **Commit**: `git add file.ts && git commit -m "Migrate file.js to TypeScript"`

## Validation Checklist

After completing all phases:

- [ ] `npx tsc --noEmit` passes (zero TypeScript errors)
- [ ] `npm run build` succeeds
- [ ] All `.js` files in `src/` migrated (except rollup config)
- [ ] App loads without console errors
- [ ] Audio playback works
- [ ] Downloads work
- [ ] Settings persist
- [ ] Navigation works
- [ ] Test on KaiOS 2.5 device
- [ ] Test on KaiOS 3.0 device

## Estimated Timeline

- Phase 1: 30 min (type infrastructure)
- Phase 2: 1 hour (foundation)
- Phase 3: 1.5 hours (core infrastructure)
- Phase 4: 1 hour (KaiOS shims)
- Phase 5: 2 hours (audio system)
- Phase 6: 2.5 hours (downloads)
- Phase 7: 1.5 hours (push notifications)
- Phase 8: 45 min (transcripts)
- Phase 9: 1 hour (workers & entry)
- **Total: ~12 hours** (can be split across multiple sessions)

## Risk Mitigation

- **Babel Issues**: If Babel fails, check for `const enum` or `namespace` usage (not supported)
- **Circular Dependencies**: Use `import type` to break cycles
- **Runtime Errors**: Keep all existing runtime type checks (don't rely on TypeScript)
- **Type Errors**: When stuck, use `any` and add `// TODO: improve typing` comment
- **Build Size**: Verify bundle sizes don't increase significantly

## Success Criteria

Migration complete when:

1. Zero `.js` files remain in `src/` (excluding config)
2. TypeScript compilation succeeds
3. Production build works
4. All features tested on both KaiOS versions

At first glance, the plan seemed fine although I would prefer to not “use any liberally.” For small files with few dependencies, this was sufficient. However, I exhausted my Claude Pro daily usage very quickly and found it got stuck far too often. Claude reinvented the wheel (didn’t use kaios-types) and was too liberal with type assertions to any. For better results, I needed to be more specific about the changes I expected, more methodical in iterating across files, and narrower in scope with each prompt.

I noticed most failures came when converting highly-interconnected components (itself a code smell for refactor, but that’s a problem for another day). My approach was similar to the Strangler Fig: don’t arbitrarily walk file-by-file, but instead focus on the “outermost” independent components with the least imports. As Gemini put it, “start with leaf utilities (e.g., src/strings/, src/utils/) and move up to components.” For PodLP, this meant the parts of the code that handle transcripts, translations, push notifications, and downloads.

Moving back to Gemini, it ended up defining three agents:

Architect: responsible for configuring the build pipeline (tsconfig.json, rollup.config.js, etc) to support TypeScript while maintaining KaiOS compatibility.
Gardener: responsible for managing this project and it’s configuration, dependencies, and code formatting standards
Migrator: responsible for converting the codebase from JavaScript to TypeScript and porting application to ensure type safety

Here’s an exercept of the revamped migration plan:

# Upgrade Plan: Modernization & TypeScript Migration

## Overview

This document outlines the strategy to modernize the PodLP codebase by migrating from JavaScript to TypeScript. The goal is to improve developer experience and code safety while maintaining compatibility with KaiOS (Firefox 48 target).

## Phase 1: TypeScript Infrastructure

**Goal:** Enable TypeScript support in the build pipeline while **keeping Babel** for critical KaiOS down-leveling.

1. **Install Dependencies:**
 - `typescript`
 - `tslib`
 - `svelte-preprocess`
 - `@tsconfig/svelte`
 - `svelte-check` (for type checking)
 - `@rollup/plugin-typescript` (to handle .ts files in Rollup)
 - `kaios-types` (already installed or ensure it is added)

2. **Configuration:**
 - Create `tsconfig.json`:
 - Extend `@tsconfig/svelte/tsconfig.json`.
 - Set `target` to `ESNext` (let Babel handle the heavy lifting to ES5/ES6 for Firefox 48).
 - Include `kaios-types` in `compilerOptions.types`.
 - Ensure strict mode is enabled (can be loose initially).
 - Create `svelte.config.js`:
 - Configure `svelte-preprocess`.

3. **Update Build System (`rollup.config.js`):**
 - **CRITICAL:** Do NOT remove Babel. The pipeline should be TS -> Babel -> Output.
 - Import and register `svelte-preprocess` in the `svelte` plugin options.
 - Add `@rollup/plugin-typescript` to the plugin list _before_ Babel.
 - Ensure source maps are configured correctly for debugging.

## Phase 2: Migration Execution

**Goal:** Convert codebase to TypeScript.

1. **Iterative Conversion:**
 - Rename `.js` files to `.ts`.
 - Update `.svelte` files: `<script>` -> `<script lang="ts">`.
 - Fix immediate type errors.
 - Use `kaios-types` for `navigator.mozApps`, `navigator.volumeManager`, etc.
 - Start with leaf utilities (e.g., `src/strings/`, `src/utils/`) and move up to components.

2. **Type Safety:**
 - Run `npm run check` (using `svelte-check`) to identify issues.
 - Define interfaces for API responses and core data structures (Podcast, Episode).
 - Replace `any` with specific types where possible.

3. **Verification:**
 - Build the app (`npm run build`).
 - Verify the app runs in the KaiOS simulator or device (manual verification required by user).

## Phase 3: Cleanup & Documentation

1. Update `README.md` with new build instructions and TS guidelines.
2. Verify `package.json` scripts.

This process continued for several hours split across two days driven by rate limits and resource quotas. I began with Gemini 3 Pro to draft and vet the plan, then to Gemini 3 Flash and 2.5 Flash for the file-by-file conversion. Only a few highly-interconnected files caused issues, and even these were able to be converted with some manual intervention.

Testing #

When npm run build worked, I expected disaster: a bunch of mangled transpiled JavaScript that was not KaiOS compatible, littered with runtime errors, that did not resembled my app. What I got was a TypeScript codebase with just a few errors that were easy to fix.

Ironically, the very first issue I found after this TypeScript migration was a TypeError!

onAppError TypeError: _ref11.detail is undefined
Stack trace:
 onOptionClick@app://podlp.com/build/podlp.js:40504:10
 handleOptionClickEvent@app://podlp.com/build/podlp.js:60395:25
 createEventDispatcher/podlp/<@app://podlp.com/build/podlp.js:24887:10
 createEventDispatcher/podlp@app://podlp.com/build/podlp.js:24886:8
 onOptionClick@app://podlp.com/build/podlp.js:30579:10
 instance$G/click_handler_1@app://podlp.com/build/podlp.js:30623:41
 click_handler_1@app://podlp.com/build/podlp.js:30128:59
 prevent_default/podlp@app://podlp.com/build/podlp.js:24422:13

During the conversion process, liberal use of any or generic types like Event resulted in some event handlers being called with trusted user-generated events (lacking the detail property). I fixed a few function signatures to use more specific types like CustomEvent<{ action: string }>, changed the caller, and that was that.

The second issue was with a single instance where the ... spread operator was dropped, causing Svelte’s reactivity statement to not trigger and a component to not render. This was incredibly easy to spot since it caused the entire page to be blank. One more fix, and it was resolved.

The only other issues I ran into were duplication of KaiOS API types (redefining APIs already present in kaios-types). Given how little training data is available for KaiOS, it’s likely the model wasn’t able to grep for the correct API and choose instead to redefine it. I addressed most of this with a single prompt listing where to find each duplicated type definition. In the end, I even spotted a few APIs missing from kaios-types!

Results #

Sign at the summit of Mt. Watatic

After spending $43 (in Gemini credits) and an afternoon, PodLP is now fully written in TypeScript. Build stats show that the main artifact grew marginally, from 842.76 kB to 852.59 kB uncompressed (~1.2% increase). This definitely answered the question, “can AI agents migrate a non-trivial codebase from JavaScript to TypeScript?” However, I’m still reevaluating whether it should.

Unlike DHH, I still see great value in TypeScript primarily in long-term maintainability and productivity. Yes, it takes more type to write type definitions (or have AI generate them from an existing codebase). Examples like ts-sql show just how complex TypeScript types can get.

For PodLP, I see the primary value being able to iterate more quickly on new features, and to have AI implement new features with greater confidence. However, TypeScript’s value is somewhat stunted by the fact PodLP runs on a variety of KaiOS devices spanning 3 major OS versions (KaiOS 2.5, 3.0, and 4.0).

There are no KaiOS virtual machines to test against, and the KaiOS Simulator is virtually useless since it lacks support for many features and has substantially different configurations than commercial devices. Base Gecko versions like Firefox 48 aren’t good proxies either, since they have no permission model, don’t ship with system APIs, and lack newer features like display: grid cherry-picked from Firefox 52 into the corresponding KaiOS 2.5 version.

TypeScript won’t solve OS fragmentation or reliance on undocumented or under-documented proprietary APIs. But for me this was a worthwhile exercise in leveraging AI to modernize a substantial, real-world codebase that helps me maintain and improve PodLP for years to come.

Reflections on a year abroad

blog@barrasso.me (Tom Barrasso) — Wed, 10 Dec 2025 00:00:00 GMT

For a year I experienced truly “remote” work.

From Summer 2024 to Fall 2025, I spent a year traveling across Peru, Australia, Vietnam, Thailand, India, the United Kingdom, the Netherlands, Switzerland, Italy, Romania, Turkey, Cyprus, and almost half a year living in a van in New Zealand.

During this time, I worked remotely at CloudMosa as the Head of Developer Relations for Cloud Phone. Although my interest in flip phones began in 2020 when I launched PodLP, this was quite the departure from the past 5+ years in Big Tech living in Seattle. This writing is part of the long journey to unpack and make meaning from such a profound experience.

Aotearoa New Zealand 🇳🇿 #

Isolation, postcard-quality sunsets, striking mountains, flightless birds, solid 4G signal, and the kindest people I’ve ever met

Tom in Hugo, a 2000 Toyota Hiace

I’ve worked with Hugo (the static site generator) for years. This blog is built with Hugo, and so is Cloud Phone for Developers. Coincidentally, our van also came with the name “Hugo!” Fortunately, Hugo survived another 10,000km around the North & South Islands, and thanks to an Asus 4G-AX56 (powered by rooftop solar), I had WiFi wherever I went using the Spark network.

Arthur’s Pass, South Island

A 12-hour flight from San Francisco: New Zealand has no dangerous animals, no land borders, and it’s often omitted from maps. I’ve been to dark-sky preserves, but New Zealand is on another level. This is just a several second exposure on an iPhone 13 Mini.

~3 second exposure of the night sky in the Southern Hemisphere

Run by the Department of Conservation (DOC), New Zealand’s Great Walks were one of the initial draws to visit the islands. Of the 11 Great Walks, I completed 4 and hiked partway across another 5. In between tramping trips I dropped by the Nelson Dev Group and gave a talk at Ruby Nights Auckland. I launched the Cloud Phone for Developers website, was a guest on the WasmAssembly Podcast, and helped launch the MyGP app for Grameenphone, Bangladesh’s largest telecommunication company.

Kiwi crossing sign in Rakiura (Stewart Island)

No doubt, New Zealand is weird. It’s home to hobbits, alpine parrots, spherical concretions, and Steampunk HQ. I saw the world’s smallest penguins and walked up the world’s steepest street. I tried Amazake, witnessed glowworms, got into F45, and picked up a few Māori phrases.

Kea, an endangered alpine parrot, on the Milford Track

I drove on the left, lived in other people’s homes (house sitting), and had my first run-in with rites of passage where this poems came to life.

The Breeze At Dawn

The breeze at dawn has secrets to tell you.
Don’t go back to sleep!

You must ask for what you really want.
Don’t go back to sleep!

People are going back and forth
across the threshold
where the two worlds meet.

The door is round and open.
Don’t go back to sleep!

A Great Wagon, by Rumi

This was definitely a departure from riding the corporate shuttle, responding to hundreds of Workplace messages, and providing status updates at the semi-annual All Hands meeting. In many ways, I was now confronted with the paradox of choice.

Kura Tāwhiti (Castle Hill) in the South Island, New Zealand

Maya Angelou wrote that, “people will never forget how you made them feel.” I will never forget the feeling of being as far as humanly possible from the culture of busyness. The feeling when ducks and weka were my only coworkers. The feeling when projects were punctuated by a swim in a brisk alpine lake.

It’s more than just the question: “live to work or work to live?” The balance between under and overworked isn’t a fixed point. In Safi Bahcall’s book Loonshots, he attempts to quantify the conditions under which return-on-politics exceeds return-on-work. At larger companies, I’ve observed the primary motivation was compensation, and the primary form of communication was meetings. Being truly “remote” at CloudMosa, meetings were rare and the driving force I saw was the satisfaction of seeing your work help real people.

OMGOSH !
OMGOSH !
OMGOSH !
THANK YOU FOR THE LINK TO PATRICK MADRID!
YOU ARE AMAZING, TOTALLY MADE MY LIFE (ESP BC I AM HOMELESS RIGHT NOW) SO MUCH MORE OF A HAPPY PLACE TO BE. . .
I HOPE SOMEONE DOES THE SAME FOR YOU,IN WHICHEVER WAY YOU WISH. . . .
THANK YOU FOR YOUR TIME
P.S. CANT WAIT TO GET TO DOWNLOAD THEM IN 2 WEEKS, MUUUWAH.

– Anonymous PodLP User

This was an email a user sent me. Five years ago, I built PodLP because it was something I wanted myself. I continued building it for the same reason that CloudMosa builds Cloud Phone. PodLP turned into an (admittedly small) business that continues to this day.

Although sponsorship revenue keeps PodLP profitable, no doubt I won’t look back and smile at every invoice. But I’ll never forget unsolicited feedback like this.

The next chapter: rest of world #

Rest of world (ROW) is a pejorative commonly used at technology companies to mean everywhere outside of the US and Europe. I spent several weeks in each country, experiencing them more deeply than a typical American vacation but not to the same extent as New Zealand. Each place shaped my understanding of the world in ways I hadn’t expected.

Australia 🇦🇺 #

Marsupials, meetups, speed cameras, and a sausage on election day

Kangaroo near Brisbane, Australia

Growing up, I loved Zoboomafoo so naturally I was excited to visit the country full of strange animals. Yet it was I who felt watched by the insane speed enforcement cameras. After spending 6 months in small towns, it was jarring to return to large cities, many more populous than the entire country of New Zealand.

The Opera House in Sydney, Australia

I’m grateful to Frontenders Sydney for offering me the opportunity to present to 100+ developers, and for our hosts in Brisbane who prepared a classic Aussie Barbie (and so much more). Plus Australia is where I discovered Jack Davies and The Bush Chooks at a last minute concert.

Tom giving a talk at Frontenders Sydney in May 2025

I’d love to see America adopt the democracy sausage, and aspire to the return of politics summed up as “boring” and “weird”. Yet I’m not called to return to Australia. Maybe it’s the lack of prominent mountains, or abundance of deadly creatures. Maybe it’s because I don’t surf, or because I’m not interested in their $1500 coffee. Or perhaps it felt a bit too much like the parts of home that I’d rather avoid.

Vietnam 🇻🇳 #

Gastronomic excellence and highly caffeinated hustle culture

Rice terraces in Pù Luông, Vietnam

Vietnam is growing fast, and it’s abundantly clear why. It’s a place of hardcore hustle culture: operating an AirBnB, restaurant, nail salon, farming durian, brewing kombucha, and driving for Grab. Although the small demographic I encountered was biased towards tourism, it seems as if everyone run a business and has 3 jobs. After all, this is a place where you can’t put too much on a moped.

Old Vietnamese poster featuring flip phones from a Cửa Hàng ĐTDĐ (mobile phone shop)

Vietnam is where I bought my first Cloud Phone in person, a Viettel V1S 4G for ₫390,000 (~$15 USD). I also saw real people using feature phones for practical purposes, not just as part of a “digital detox.” CloudMosa also donated 100 4G Cloud Phones to provide connectivity to residents in remote areas of Vinh Long province.

Boats in Tràng An, a UNESCO World Heritage Site

If America runs on Dunkin, Vietnam runs on Highland. You can’t escape their strong, sugary drinks. Nor should you. Vietnamese coffee is delicious and its how everyone keeps going day and night.

Outside of the cities, Vietnam’s karst landscapes are stunning. Limestone towers jut out of nowhere, and rice terraces sprawl as far as the eye can see. Yet the price of progress goes beyond caffeine addiction. Like anywhere growing quickly, smog (especially in Hanoi) and serious litter pollution is common. Venture slightly off the beaten path and the ocean hardly looks safe to swim.

Thailand 🇹🇭 #

Mangosteen, meditation, and mud houses

Lotus flower near Chiang Mai, Thailand

My time in Thailand was intentionally slow. I enjoyed mangosteen-shaped ice cream (my favorite fruit), joined a yoga retreat, and took impromptu lessons on how to build houses out of clay bricks. As Lao Tzu put it, “Nature does not hurry, yet everything is accomplished.” While I raced from rice paddy to museum to coffee stand to hawker market in Vietnam, I reconnected and recalibrated in Chiang Mai and Bangkok.

Clay brick building in Thailand

India 🇮🇳 #

Rick Steves’ favorite and the “keypad mobile” capital

Monsoon season in Kochi, India

Although my time was spent in Kerala (often billed as “India Lite”), it was still quite intense. But this was one of those times when I thrived on the chaos. I roamed the streets of Kochi by rickshaw and public transport: buses, trains, and even ferries. I even found plenty of my beloved mangosteen.

When asked my favorite country, I say, “India.” While I enjoy the shock value of saying that, that’s not why I say it. I say India because it’s true. India wallops anyone’s self-assuredness. India rearranged my cultural furniture. My confidence that I understood such basics to life as time, joy, love, pain, and music was shaken. I was humbled in a way that made me a better person.
– Rick Steves

Much to the chagrin of many a mobile store salesperson, I had no interest in the latest Huawei Mate or iPhone. Eventually I bought what you can’t find on eBay: feature phones (mostly called “keypad mobiles” in India) like a Snexian Guru 4G and one of the very first Cloud Phone models, an Itel Super Guru 4G.

Europe #

A wedding in the United Kingdom kicked off the next phase of my trip, including visits with family and in-person meetings with developers in Germany and the Netherlands. Then it was back to the unfamiliar.

Switzerland 🇨🇭 #

Charming and alarmingly expensive

Cows in Switzerland

Switzerland is quaint, peaceful, and anything but flat. It’s a place where you’re not wanting for views, where trains arrive to the minute, and a $10 lunch no longer exists. Once again I followed Rick Steves’ advice and visited Gimmelwald. While the cozy vibes were welcome during a very rainy summer, what made it special was meeting locals on the train who invited us for tea.

Chilchbalm marker at 1631m

During a downpour, Heinz and Annelies recounted their own travels decades earlier during an era when visa applications were made in paper and travelers cheques were still in fashion. By comparison, my own journey was far less harrowing. Agonizing or not, my journey was my own. The world has clearly changed in half a century, and I’m fortunate to be able to be put to productive use anywhere I can secure a somewhat stable internet connection.

Chilchbalm marker at 1631m

The hikes throughout Lauterbrunnen and the Alps were incredible, but taking a series of gondolas and trains up several thousand meters feels like cheating. Hard work that leads to a sense of accomplishment is motivating. It’s more than just the IKEA effect.

Surprisingly, a last minute hike to Chilchbalm proved more memorable. It’s an awesome glacial basin, and one of the view places outside of National Parks like Glacier and the Grand Tetons that I truly felt small.

Italy 🇮🇹 #

La vita è bella

La festa della Madonna Bianca in Portovenere, Italy

Some say, “if you fail to plan, you plan to fail.” Others believe that, “life happens while you’re busy making other plans.” As a Technical Program Manager (TPM), you’re expected to have Plans A through E for when the inevitable goes wrong.

The White Madonna Festival was one of those unplanned highlights that I only learned about day of thanks to flyers on the street. Hiking the Cinque Terre was incredible. So was swimming in the Ligurian Sea and eating lemon gelato in Corniglia. But neither rival the unplanned nighttime visit to the Grotto of Lord Byron celebrating a 14th century plague miracle by lighting more than 2,000 roman candles.

WhatsBar in Ravenna, Italy

The rest of Italy (namely Rome) was impressive, but I had high expectations that couldn’t be exceeded by the dense crowds, sweltering heat, and fear of pickpockets. I was also perplexed by WhatsBar, a 24-hour snack vending machine and ATM in Ravenna that appears to combine the names and logos of WhatsApp and the Java programming language.

Romania 🇷🇴 #

A more rugged and affordable Switzerland

The Carpathian Mountains near Cheia, Romania

Romania was a sleeper hit and another last minute decision. It came on my radar because I met a Romanian at a tech meetup in Auckland. That’s all the planning, and it turned out to be incredible.

After reconnecting with my Romanian acquaintance on WhatsApp, I learned it’s best to hike in groups because of the prevalence of brown bears. Although no bears were on this hike, it proved to be sound advice for making friends. Plus, I did eventually see bears.

Brown bear near the Transfăgărășan in Romania

Cyprus 🇨🇾 #

Adorable cats and a return to building

Calico Cyprus cat sleeping at a cafe

Cyprus was a place I had no connection to. I’m still not quite sure what drew me there. But the intense daytime heat let me feel less guilty spending time inside building my hackathon project, Backyard Birds, in between sampling wines and visits to ancient ruins.

It turns out Cyprus cats have ruled the island for over 10,000 years since they were apparently brought from Egypt to eradicate snakes. They’re are so cute, I made a montage video of the many cats I encountered.

KaiOS poster in Nicosia, Cyprus

As a software engineer, there’s a sense of excitement and pride seeing your work in the real world. I am often asked by folks in Africa and South Asia why I work on flip phones when they’re mostly for seniors and hipsters in the west. This flyer for the iPRO K2 running KaiOS was probably the first time I encountered an advertisement for KaiOS in real life.

From the data, I knew my work reached far flung places. Five and a half years after launch, PodLP has active listeners in over 170+ countries including Cyprus! Despite a $0 marketing budget, PodLP still gets organically mentions and linked on podcasts in places where it’s most popular like India.

‘Stop making drama, you’re not Shakespeare’ in Nicosia, Cyprus

I have no personal connection to this poster, it’s just sage advice.

Türkiye 🇹🇷 #

Cats, cats, and more cats

Cat at a bazaar in Istanbul

The final stop on my year-long adventure was Turkey, where I experienced life in a different set of rhythms like waking up to the morning adhan (call to prayer) and greeting the local cats. Following their successful invasion of Cyprus, cats conquered Istanbul where they remain in charge to this day.

Fez the Cat

With some spare time and an extended deadline, I decided to work on another submission for the Yoto Hackathon: Fez the Cat. Clearly inspired by my time in Istanbul, Fez tells 26 stories, one for each letter of the alphabet. Each story is almost a pangram, a sequence that containers every letter of the alphabet from A-Z. Except each story is missing one letter which the listener has to guess.

Fez gave me more time to explore vibe coding and tinker with text-to-speech (TTS) voices in ElevenLabs. Backyard Birds and Fez the Cat were the start of a return to building that continues by hacking at Sundai Club and open sourcing many of my projects over the past few years.

Returning Home #

It’s a strange and disorienting feeling returning home after being away for so long. This post is just one part of processing the journey. I still have much to unfold on the nature of work, the call to wander, and the meaning of “home.” But for now I’m intent on building something new that I can feel proud of.

Rotating content daily with Cloudfront Functions

blog@barrasso.me (Tom Barrasso) — Thu, 25 Sep 2025 00:00:00 GMT

How to use Cloudfront Functions to rotate content daily at roughly midnight local time.

Content Rotation #

I built two projects for the Yoto Hackathon: Backyard Birds and Fez the Cat. Fez tells a new story each each that contains every letter of the alphabet, except for one letter that listeners need to guess.

Fez’s stories are almost pangrams, the most famous pangram being:

The quick brown fox jumps over the lazy dog

After writing and editing 26 scripts (one for each letter A-Z), I used ElevenLabs to generate audio using a custom voice. Now with 26 MP3 files, I needed to automatically change the story of the day. Yoto allows playlists to include streaming tracks where the device makes an HTTP requests to a static URL each time the user inserts the card.

To rotate content daily I considered:

Serving fully static using Cloudfront with an S3 origin, then using a Lambda function on a daily EventBridge scheduler to copy one of the 26 stories as “today’s story”
Serving static content using either a Cloudfront Function or Lambda@Edge function to select an S3 object based on the current day in the user’s local time using the CloudFront-Viewer-Time-Zone header

I choose the second option because it’s cumbersome to explain that, “the story updates every day at Midnight UTC.” I opted instead for a Cloufront Function because they are very low latency and much cheaper than Lambda@Edge. Cloudfront Functions cost a flat $0.10 per 1 million invocations vs. Lambda@Edge which costs approximately $0.60 per 1 million invocations (price depends on region) plus execution time and memory measured in GB-seconds.

There’s nothing wrong with Lambda@Edge, I was just feeling frugal plus What Could Go Wrong?™

Limited Runtime #

Cloudfront Functions has a very limited runtime. The more recent cloudfront-js-2.0 runtime supports ECMAScript 5.1 and some ES6 features. Notably, it lacks networking (no fetch), file system access (no fs), environment variables, or timers.

Important for me, the Date.toLocaleString implementation supported in Cloudfront Functions follows the ECMAScript 5.1 standard where it accepts no arguments. What could have just been a single line with now.toLocaleString("de-DE", { timeZone: 'Europe/Berlin'}) got a lot more complicated.

Ask ChatGPT #

TLDR - Don’t ask AI when there is lot of nuance in a specific runtime environment.

I made the mistake of asking ChatGPT, Claude, and Gemini for help. Each gave me a convincing option. One response suggested I use the non-existent CloudFront-Viewer-Time-Offset header to calculate time in UTC and offset it according to the user’s local time. This would have been great, except a GitHub search yielded exactly 0 results.

Another response indicated that I could use the Date.toLocaleDateString function which, “returns a string with a language-sensitive representation of the date portion of this date in the local timezone.” Spoiler alert: The Cloudfront Functions runtime doesn’t support the Intl API, and “local time” is function start time, always in UTC. This makes sense since all Cloudfront Functions have a strict 1ms execution limit!

Time to Pivot? #

At this point, it would have been much simpler to just migrate over to Lambda@Edge which supports the nodejs22.x runtime, but I was determined to shoehorn a solution using Cloudfront Functions! I could calculate Midnight UTC, and I knew the IANA name of the user’s timezone, so I just needed to map IANA names to UTC offsets to calculate midnight local time.

To map IANA timezones to UTC offsets I considered:

Storing timezone name to UTC offsets in Cloudfront KeyValueStore
Using an NPM package that contained the mappings
Inlining the mappings within my application code

Another important limitation of Cloudfront Functions is that the maximum function size is just 10 KB! Unfortunately, I could not find any NPM packages that would comfortably fit within that limit. Cloudfront KeyValueStore isn’t too expensive at $0.03 per 1 million reads, and probably would have been a convenient long-term solution, especially if I had multiple functions rotating content and reading from the same KV store.

Time Zone Mappings #

I opted to have Gemini create a map from IANA time zone name to UTC offset. To keep the mapping well within the 10 KB limit, I adjusted the mapping structure for the smallest file size. The original mapping was a single map like { "Africa/Kigali": 120 }, but it was well above 10 KB. Smaller was a nested variant representing IANA time zone names like Africa/Kigali mapping to Africa.Kigali with the timezone offset at index 17 in the UTC_OFFSETS_IN_MINUTES array.

const UTC_OFFSETS_IN_MINUTES = [
 -720, -660, -600, -570, -540, -480, -420, -360, -300, -240, -210, -180,
 -150, -120, -60, 0, 60, 120, 180, 210, 240, 270, 300, 330, 345, 360,
 390, 420, 480, 525, 540, 570, 600, 630, 660, 720, 765, 780, 840
];

const TIMEZONES = {
 Africa: {
 Abidjan: 15, Accra: 15, Addis_Ababa: 18, Algiers: 16, Asmara: 18, Asmera: 18,
 Bamako: 15, Bangui: 16, Banjul: 15, Bissau: 15, Blantyre: 17, Brazzaville: 16,
 Bujumbura: 17, Cairo: 17, Casablanca: 16, Ceuta: 16, Conakry: 15, Dakar: 15,
 Dar_es_Salaam: 18, Djibouti: 18, Douala: 16, El_Aaiun: 16, Freetown: 15,
 Gaborone: 17, Harare: 17, Johannesburg: 17, Juba: 17, Kampala: 18, Khartoum: 17,
 Kigali: 17, Kinshasa: 16, Lagos: 16, Libreville: 16, Lome: 15, Luanda: 16,
 Lubumbashi: 17, Lusaka: 17, Malabo: 16, Maputo: 17, Maseru: 17, Mbabane: 17,
 Mogadishu: 18, Monrovia: 15, Nairobi: 18, Ndjamena: 16, Niamey: 16,
 Nouakchott: 15, Ouagadougou: 15, 'Porto-Novo': 16, Sao_Tome: 15, Timbuktu: 15,
 Tripoli: 17, Tunis: 16, Windhoek: 17
 },
 // ...
];

Still fairly clean, this version was 9.98 KB (7.1 KB minified), and I still needed space for my function code. After a few more attempts, I landed on:

const offsets = [
 -720, -660, -600, -570, -540, -480, -420, -360, -300, -240, -210, -180,
 -150, -120, -60, 0, 60, 120, 180, 210, 240, 270, 300, 330, 345, 360,
 390, 420, 480, 525, 540, 570, 600, 630, 660, 720, 765, 780, 840
];

const zones = {
 Africa: {
 15: 'Abidjan Accra Bamako Banjul Bissau Conakry Dakar Freetown Lome Monrovia Nouakchott Ouagadougou Sao_Tome Timbuktu',
 16: 'Algiers Bangui Brazzaville Casablanca Ceuta Douala El_Aaiun Kinshasa Lagos Libreville Luanda Malabo Ndjamena Niamey Porto-Novo Tunis',
 17: 'Blantyre Bujumbura Cairo Gaborone Harare Johannesburg Juba Khartoum Kigali Lubumbashi Lusaka Maputo Maseru Mbabane Tripoli Windhoek',
 18: 'Addis_Ababa Asmara Asmera Dar_es_Salaam Djibouti Kampala Mogadishu Nairobi'
 },
 // ...
];

I estimated that I needed about ~3.5 KB for my function code unminified, and this representation got down to 6.4 KB minified so it fit! The full mapping is available below as a GitHub Gist.

What about Daylight Savings? #

This static timezone mapping has several obvious ~~flaws~~ limitations, most notably:

It’s static: sometimes countries or territories change timezones
It doesn’t account for Daylight Savings Time (DST)

That said, countries changing timezones isn’t a frequent occurrence. It’s even less likely that I’ll have many users in such countries. Plus, there’s growing evidence that daylight savings is unhealthy.

So this approach doesn’t really rotate content at mightnight local time. Instead, it adjusts at approximately midnight ±1 hour local time, which I’d say is Good Enough™.

Complete Timezone Mapping #

This function is intended to map timezone names to UTC offsets (in minutes), and fit within the constraints of the Cloudfront Function runtime environment without any external dependencies.

timezone-to-offset.js

const offsets = [
 -720, -660, -600, -570, -540, -480, -420, -360, -300, -240, -210, -180,
 -150, -120, -60, 0, 60, 120, 180, 210, 240, 270, 300, 330, 345, 360,
 390, 420, 480, 525, 540, 570, 600, 630, 660, 720, 765, 780, 840
];

const zones = {
 Africa: {
 15: 'Abidjan Accra Bamako Banjul Bissau Conakry Dakar Freetown Lome Monrovia Nouakchott Ouagadougou Sao_Tome Timbuktu',
 16: 'Algiers Bangui Brazzaville Casablanca Ceuta Douala El_Aaiun Kinshasa Lagos Libreville Luanda Malabo Ndjamena Niamey Porto-Novo Tunis',
 17: 'Blantyre Bujumbura Cairo Gaborone Harare Johannesburg Juba Khartoum Kigali Lubumbashi Lusaka Maputo Maseru Mbabane Tripoli Windhoek',
 18: 'Addis_Ababa Asmara Asmera Dar_es_Salaam Djibouti Kampala Mogadishu Nairobi'
 },
 America: {
 2: 'Adak Atka', 4: 'Anchorage Juneau Metlakatla Nome Sitka Yakutat', 5: 'Ensenada Los_Angeles Santa_Isabel Tijuana Vancouver',
 6: 'Boise Cambridge_Bay Creston Dawson Dawson_Creek Denver Edmonton Fort_Nelson Hermosillo Inuvik Mazatlan Ojinaga Phoenix Shiprock Whitehorse Yellowknife',
 7: 'Bahia_Banderas Belize Chicago Costa_Rica El_Salvador Guatemala Indiana/Knox Indiana/Tell_City Knox_IN Managua Matamoros Menominee Merida Mexico_City Monterrey North_Dakota/Beulah North_Dakota/Center North_Dakota/New_Salem Rainy_River Rankin_Inlet Regina Resolute Swift_Current Tegucigalpa Winnipeg',
 8: 'Atikokan Bogota Cancun Cayman Coral_Harbour Detroit Eirunepe Fort_Wayne Grand_Turk Havana Indiana/Indianapolis Indiana/Marengo Indiana/Petersburg Indiana/Vevay Indiana/Vincennes Indiana/Winamac Indianapolis Iqaluit Jamaica Kentucky/Louisville Kentucky/Monticello Lima Louisville Montreal Nassau New_York Nipigon Panama Pangnirtung Port-au-Prince Porto_Acre Rio_Branco Thunder_Bay Toronto',
 9: 'Anguilla Antigua Aruba Asuncion Barbados Blanc-Sablon Boa_Vista Campo_Grande Caracas Cuiaba Curacao Dominica Glace_Bay Goose_Bay Grenada Guadeloupe Guyana Halifax Kralendijk La_Paz Lower_Princes Manaus Marigot Martinique Moncton Montserrat Port_of_Spain Porto_Velho Puerto_Rico Santiago Santo_Domingo St_Barthelemy St_Kitts St_Lucia St_Thomas St_Vincent Thule Tortola Virgin',
 10: 'St_Johns', 11: 'Araguaina Bahia Belem Buenos_Aires Catamarca Cordoba Cayenne Fortaleza Godthab Jujuy Maceio Mendoza Miquelon Montevideo Nuuk Paramaribo Punta_Arenas Recife Rosario Santarem Sao_Paulo Stanley',
 13: 'Noronha', 14: 'Scoresbysund', 15: 'Danmarkshavn',
 Argentina: { 11: 'Buenos_Aires Catamarca ComodRivadavia Cordoba Jujuy La_Rioja Mendoza Rio_Gallegos Salta San_Juan San_Luis Tucuman Ushuaia' }
 },
 Antarctica: {
 11: 'Palmer Rothera', 15: 'Troll', 18: 'Syowa', 22: 'Mawson', 25: 'Vostok', 27: 'Davis',
 32: 'DumontDUrville Macquarie', 34: 'Casey', 35: 'McMurdo South_Pole GMT+12'
 },
 Asia: {
 17: 'Beirut Famagusta Gaza Hebron Jerusalem Nicosia Tel_Aviv', 18: 'Aden Amman Baghdad Bahrain Damascus Djibouti Istanbul Kuwait Qatar Riyadh',
 19: 'Tehran', 20: 'Baku Dubai Muscat Tbilisi Yerevan', 21: 'Kabul',
 22: 'Aqtau Aqtobe Ashgabat Ashkhabad Atyrau Dushanbe Karachi Oral Qyzylorda Samarkand Tashkent Yekaterinburg',
 23: 'Calcutta Colombo Kolkata', 24: 'Kathmandu Katmandu',
 25: 'Almaty Bishkek Dacca Dhaka Kashgar Omsk Qostanay Thimbu Thimphu Urumqi', 26: 'Rangoon Yangon',
 27: 'Bangkok Barnaul Ho_Chi_Minh Hovd Jakarta Krasnoyarsk Novokuznetsk Novosibirsk Phnom_Penh Pontianak Saigon Tomsk Vientiane',
 28: 'Brunei Choibalsan Chongqing Chungking Hong_Kong Irkutsk Kuala_Lumpur Kuching Macao Macau Makassar Manila Shanghai Singapore Taipei Ulaanbaatar Ulan_Bator',
 30: 'Dili Jayapura Khandyga Pyongyang Seoul Tokyo Yakutsk', 32: 'Chita Ust-Nera Vladivostok',
 34: 'Magadan Sakhalin Srednekolymsk', 35: 'Anadyr Kamchatka'
 },
 Atlantic: { 9: 'Bermuda', 11: 'Stanley', 13: 'South_Georgia', 14: 'Azores Cape_Verde', 15: 'Canary Faeroe Faroe Madeira Reykjavik St_Helena', 16: 'Jan_Mayen' },
 Australia: { 28: 'Perth West', 29: 'Eucla', 31: 'Adelaide Broken_Hill Darwin North South Yancowinna', 32: 'ACT Brisbane Canberra Currie Hobart Lindeman Melbourne NSW Queensland Sydney Tasmania Victoria', 33: 'LHI Lord_Howe' },
 Brazil: { 8: 'Acre', 9: 'West', 11: 'East', 13: 'DeNoronha' },
 Canada: { 5: 'Pacific', 6: 'Mountain Yukon', 7: 'Central Saskatchewan', 8: 'Eastern', 9: 'Atlantic', 10: 'Newfoundland' },
 Chile: { 7: 'EasterIsland', 9: 'Continental' },
 Etc: {
 0: 'GMT+11', 1: 'GMT+10', 6: 'GMT+9', 7: 'GMT+8', 8: 'GMT+7', 9: 'GMT+6', 10: 'GMT+5', 11: 'GMT+4', 12: 'GMT+3', 13: 'GMT+2', 14: 'GMT+1',
 15: 'GMT GMT+0 GMT-0 GMT0 Greenwich UCT UTC Universal Zulu', 16: 'GMT-1', 17: 'GMT-2', 18: 'GMT-3', 20: 'GMT-4', 22: 'GMT-5', 25: 'GMT-6', 27: 'GMT-7', 28: 'GMT-8', 30: 'GMT-9',
 32: 'GMT-10', 34: 'GMT-11', 35: 'GMT-12 GMT+12', 37: 'GMT-13', 38: 'GMT-14'
 },
 Europe: {
 15: 'Belfast Guernsey Isle_of_Man Jersey Lisbon London',
 16: 'Amsterdam Andorra Belgrade Berlin Bratislava Brussels Budapest Busingen Copenhagen Dublin Gibraltar Ljubljana Luxembourg Madrid Malta Monaco Oslo Paris Podgorica Prague Rome San_Marino Sarajevo Skopje Stockholm Tirane Vaduz Vatican Vienna Warsaw Zagreb Zurich',
 17: 'Athens Bucharest Chisinau Famagusta Helsinki Kaliningrad Kiev Mariehamn Nicosia Riga Sofia Tallinn Tiraspol Uzhgorod Vilnius Zaporozhye',
 18: 'Istanbul Kirov Minsk Moscow Simferopol Volgograd', 20: 'Astrakhan Samara Saratov Ulyanovsk'
 },
 Indian: { 18: 'Antananarivo Comoro Mayotte', 20: 'Mahe Mauritius Reunion', 22: 'Kerguelen Maldives', 25: 'Chagos', 26: 'Cocos', 27: 'Christmas' },
 Mexico: { 5: 'BajaNorte', 6: 'BajaSur', 7: 'General' },
 Pacific: {
 '-1': 'GMT+12', 1: 'Midway Niue Pago_Pago Samoa', 2: 'Honolulu Johnston Rarotonga Tahiti', 3: 'Marquesas', 4: 'Gambier', 5: 'Pitcairn', 7: 'Easter Galapagos',
 30: 'Palau', 32: 'Chuuk Guam Port_Moresby Saipan Truk Yap', 34: 'Bougainville Efate Guadalcanal Kosrae Norfolk Noumea Pohnpei Ponape',
 35: 'Auckland Fiji Funafuti Kwajalein Majuro Nauru Tarawa Wake Wallis', 36: 'Chatham', 37: 'Apia Enderbury Fakaofo Kanton Tongatapu', 38: 'Kiritimati'
 },
 US: { 2: 'Aleutian Hawaii', 4: 'Alaska', 5: 'Pacific', 6: 'Arizona Mountain', 7: 'Central Indiana-Starke', 8: 'East-Indiana Eastern Michigan', 1: 'Samoa' },
 2: 'HST', 5: 'PST8PDT', 6: 'MST MST7MDT Navajo', 7: 'CST6CDT', 8: 'Cuba EST EST5EDT Jamaica', 15: 'GB GB-Eire GMT GMT+0 GMT-0 GMT0 Greenwich Iceland Portugal UCT UTC Universal WET Zulu',
 16: 'Arctic/Longyearbyen Atlantic/Jan_Mayen CET Eire MET Poland', 17: 'EET Egypt Israel Libya', 18: 'Asia/Istanbul Europe/Istanbul Turkey W-SU',
 19: 'Iran', 28: 'Hongkong PRC ROC Singapore', 30: 'Japan ROK', 35: 'Kwajalein NZ', 36: 'NZ-CHAT'
};

function getUtcOffset(tz) {
 const parts = tz.split('/');
 const city = parts.pop();
 let node = zones;

 for (let i = 0, e = parts.length; i < e; i++) {
 node = node[parts[i]];
 if (!node) return 0;
 }

 for (const key in node) {
 const val = node[key];
 if (typeof val === 'string' && (' ' + val + ' ').indexOf(' ' + city + ' ') !== -1) {
 return offsets[key];
 }
 }

 return 0;
}

Deploy an Elixir + Phoenix web app on AWS EC2

blog@barrasso.me (Tom Barrasso) — Tue, 09 Sep 2025 00:00:00 GMT

Using GitHub Actions to automatically build and deploy an Elixir + Phoenix web app on AWS EC2 running Amazon Linux 2023

At a glance #

Below is a GitHub Action with two steps that builds an Elixir + Phoenix release binary using Docker and deploys the binary onto an AWS EC2 instance running Amazon Linux 2023. This approach worked fairly well for my hackathon project, but be warned that single-instance deployments like this are not horizontally scalable or highly available.

Why Elixir? #

I chose to build Backyard Birds in Elixir because Hackathons are a good opportunity to explore new technology. I first learned about Elixir back in 2019 and generally liked the functional syntax and “let it crash” ethos, centralizing error and retry logic inside a supervisor process.

Given 6 years had passed since I first tried Elixir, I assumed it would be smooth sailing. Initially setting up a Phoenix web app and running it locally was very easy. Installing dependencies using the Elixir build tool, mix, was just as simple as npm.

The first obstacle I faced was the lack of official Hex packages. Most notably, there was no AWS SDK. I choose to use aws-elixir which worked well enough, but it was poorly documented, didn’t feel very idiomatic, and annoying didn’t have separate packages for each service so I had to compile hundreds of modules.

Second, coming from TypeScript, I missed static types. jason made it easy to parse JSON responses, but I just got back tuples {:ok, %{}} with a Map as the I had to manually extract values from. Folks on the Elixir Discord were incredibly helpful and suggested I consider making structs to represent API responses. This was a bit cumbersome but gave me a bit more structural safety when handling various JSON payloads.

defmodule Yoto.Models.DisplayIcon do
 @moduledoc "Represents a display icon uploaded for a Card."

 @derive {Jason.Encoder, only: [:mediaId, :userId, :displayIconId, :url, :new]}
 defstruct [
 :mediaId,
 :userId,
 :displayIconId,
 :url,
 :new
 ]
end

I had mixed luck using LLMs like ChatGPT and agentic coding tools like Claude Code with Elixir. As a beginner, it robbed me of the experience (sometimes painful) that comes when you learn a new language. Worse, it often gaslit me by making up non-existent functions in the Elixir standard library or suggesting the language had features that it did not. I often got syntactically invalid “Elixir” from ChatGPT or Claude.

Deploying to AWS #

After much struggle, I finally had an Elixir app running locally that I was happy with. This is when things got surprisingly difficult. I develop on an M-series MacBook (arm64), and I wanted to build and deploy on AWS since I already had an account and domain name in Route53. Yet there’s surprisingly little prior art showing how to deploy Elixir on AWS EC2, and even less showing how to do automated, continuous deployments using GitHub Actions.

My preference was to automatically build my Elixir app an AWS EC2 instance with a Gravitron3 (arm64) CPU running Amazon Linux 2023 because this was the cheapest, and likely most secure, default configuration. With great help from the folks on Discord, I tried:

⛔ GitHub Action + arm64 = Dead End

Building on an arm64 runner (in Public Beta) using ubuntu-24.04-arm in the hopes of deploying to an EC2 instance with a Gravitron CPU. My Actions sat idle for a day before hitting a timeout. arm64 runners were never available to pick up my Action.

⛔ GitHub Action + Ubuntu (default) = Dead End

GitHub generously provides free compute for Actions which defaults to Ubuntu 22 running on an x86_64 CPU. Building directly within GitHub Actions and running on Amazon Linux 2023 resulted in a discrepancy between the glibc version used to compile the service and the server running it.

🏆 Build and deploy on the same environment

The best solution was to ensure the build and runtime environments matched as closely as possible. In order to do that, I used Docker to build from a amazonlinux:2023 base image, then download and install Elixir, Erlang, and OTP. Amazon Linux is based on Fedora, but Elixir and Erlang aren’t available via the dnf package manager using it’s default repositories so they had to be build from source and installed manually.

The resulting binary is then copied using Secure File Copy (SCP) onto my EC2 instance using a private key stored in GitHub Secrets. Then a script is run to create a systemd unit file, and the service is started.

This approach actually worked quite well for a single, small EC2 instance. Presumably there’s some downtime during deployments when the running service is stopped and the new service is started. This was too short to actually perceive, and more than acceptable for a hackathon project.

`tmpfs` Missteps #

I picked the smallest EC2 instance size because I didn’t expect significant traffic, and I reviewed my app as primarily I/O bound. However, I forgot that there was a single step in a workflow I wrote where ImageMagick is used to scale down and pixelate a 1024x1024 image from ChatGPT into a 16x16 pixel art icon for Yoto. All data in Elixir is immutable and passed via value. I was probably overly cautious, so to avoid keeping the PNG file in memory throughout the workflow, I instead wrote it to a temporary file and passed the file name instead.

A problem arose when temporary files appeared to not get deleted, and the partition ran out of disk space. Calls to the mogrify library (which in turn just runs system commands to System.cmd) failed due to insufficient space. After some research, I realized the default tmpfs size is half of physical RAM without swap. That didn’t leave a lot of space on my t3.nano instance with just 0.5GB of memory.

I ended up using PrivateTmp, a systemd setting for sandboxing, to create a new namespace for /tmp and /var/tmp. This seems like best practice, and make sure no other process was contributing to this issue. I also used the briefly library to ensure temporary files were deleted shortly after the workflow execution completed.

Cloudfront VPC Origin doesn’t play nice with WebSockets #

Perhaps the biggest dead end I faced was with AWS Cloudfront’s VPC Origin configurations. This let me set my EC2 instance, inside of a private subnet in a Virtual Private Cloud (VPC), as an origin server for a Cloudfront distribution. It seemed like a great solution: I could use ACM to auto-renew my SSL certificates, Route53 to manage the DNS entries, and I had a Content Delivery Network (CDN) in front of my small EC2 instance to reduce load via caching.

However, I quickly realized that my app didn’t work as expected because the Phoenix client couldn’t establish a WebSockets connection to my server. I enabled Cloudfront logging and saw the HTTP 502 Bad Gateway errors showed log entries for OriginDnsError in CloudWatch. I found several similar issues, and after some consultation on the AWS Discord, realized this was a fundamental limitation within Cloudfront that I could not overcome. In the end, I swapped WebSockets for HTTP polling during wait states when a Yoto card was being generated.

Lesson learned: CloudFront does not support WebSockets for VPC Origins pointing to an EC2 instance. It may work if you’re using a load balancer.

GitHub Action to Build + Deploy an Elixir service on AWS EC2 running AL2023 #

This GitHub Action uses Docker to build a release binary of an Elixir + Phoenix web app on Amazon Linux 2023 (AL2023). GitHub Container Registry (GHCR) is used to cache intermediate build steps to reduce subsequent build times. The second step uses SCP to copy a tarball of the binary onto an EC2 host, then uses Secure Shell (SSH) to start a systemd service of the Phoenix web app.

Secrets #

The following values need to be added to your GitHub repository under Settings > Secrets and variables > Actions.

Secret Name	Description	Example Values
`EC2_HOST`	The SSH host with port	`172.32.18.129` or `ec2-172-32-18-129.us-east-2.compute.amazonaws.com`
`EC2_SSH_KEY`	The private SSH key, in `.pem` file format	Contents of your `.pem` key file
`EC2_USER`	The SSH user	`ec2-user` (default for Amazon Linux)
`ENV_VARS`	Environment variables in `.env` format	`DATABASE_URL=postgres://...` `API_KEY=abc123`
`RELEASE_COOKIE`	The release cookie for distributed Erlang	Value from `releases/COOKIE` or generate with `mix release.init`
`SECRET_KEY_BASE`	Phoenix secret key base	Run `mix phx.gen.secret` to generate

deploy-elixir-ec2.yml

name: Build & Deploy Phoenix (linux/x86) to EC2

on:
 push:
 branches: [ "main" ]
 workflow_dispatch:

env:
 MIX_ENV: prod
 ELIXIR_VERSION: "1.18.4" # adjust as needed
 OTP_VERSION: "27.3.4.2" # match what you have in prod
 BASE_OTP_VERSION: "27" # match what you have in prod
 APP_NAME: "myapp" # lower_snake_case as created by mix new
 PHX_PORT: "4000"
 PHX_HOST: "example.com"

jobs:
 build:
 permissions:
 contents: read
 packages: write

 name: Build linux/x86 release
 runs-on: ubuntu-latest
 environment: prod

 steps:
 - name: Checkout
 uses: actions/checkout@v4

 - name: Set up Docker Buildx
 uses: docker/setup-buildx-action@v3
 with:
 buildkitd-flags: --debug
 install: true
 driver-opts: |
 image=moby/buildkit:buildx-stable-1
 network=host

 - name: Create optimized Dockerfile
 run: |
 cat <<EOF > Dockerfile.build
 FROM amazonlinux:2023 AS base

 # Install build tools and dependencies (cached layer)
 RUN dnf update -y && \
 dnf install -y \
 git tar gzip gcc gcc-c++ make wget \
 openssl-devel ncurses-devel libxslt libxml2 \
 openssl-static ncurses-static zlib-static \
 unzip libtool \
 --skip-broken && \
 dnf clean all

 # Download stage - separate for early failure and caching
 FROM base AS downloader
 ARG OTP_VERSION
 ARG ELIXIR_VERSION
 ARG BASE_OTP_VERSION

 # Download files in parallel where possible
 RUN echo "Downloading OTP \${OTP_VERSION} and Elixir \${ELIXIR_VERSION}..." && \
 wget -q --spider "https://github.com/erlang/otp/releases/download/OTP-\${OTP_VERSION}/otp_src_\${OTP_VERSION}.tar.gz" && \
 wget -q --spider "https://github.com/elixir-lang/elixir/releases/download/v\${ELIXIR_VERSION}/elixir-otp-\${BASE_OTP_VERSION}.zip" && \
 wget -q "https://github.com/erlang/otp/releases/download/OTP-\${OTP_VERSION}/otp_src_\${OTP_VERSION}.tar.gz" -O /tmp/otp_src.tar.gz & \
 wget -q "https://github.com/elixir-lang/elixir/releases/download/v\${ELIXIR_VERSION}/elixir-otp-\${BASE_OTP_VERSION}.zip" -O /tmp/elixir-precompiled.zip & \
 wait

 # OTP build stage - heavily optimized
 FROM downloader AS otp-builder
 COPY --from=downloader /tmp/otp_src.tar.gz /tmp/

 RUN echo "Building OTP with optimizations..." && \
 tar -xzf /tmp/otp_src.tar.gz -C /tmp && \
 cd /tmp/otp_src_* && \
 ./configure \
 --disable-jit \
 --disable-hipe \
 --disable-sctp \
 --disable-silent-rules \
 --enable-shared-zlib \
 --enable-threads \
 --with-ssl \
 --without-javac \
 --without-odbc \
 --without-wx && \
 make -j\$(nproc) && \
 make install && \
 rm -rf /tmp/*

 # Final runtime stage
 FROM base AS runtime

 # Copy OTP from builder stage
 COPY --from=otp-builder /usr/local /usr/local

 # Install Elixir from precompiled binary
 COPY --from=downloader /tmp/elixir-precompiled.zip /tmp/
 RUN unzip -q /tmp/elixir-precompiled.zip -d /usr/local/elixir && \
 ln -sf /usr/local/elixir/bin/elixir /usr/local/bin/elixir && \
 ln -sf /usr/local/elixir/bin/mix /usr/local/bin/mix && \
 ln -sf /usr/local/elixir/bin/iex /usr/local/bin/iex && \
 rm -f /tmp/elixir-precompiled.zip

 # Verify installations and pre-install common tools
 RUN erl -version && elixir --version && \
 mix local.hex --force && \
 mix local.rebar --force

 # Set up working directory
 WORKDIR /app
 EOF

 - name: Log in to GitHub Container Registry
 uses: docker/login-action@v3
 with:
 registry: ghcr.io
 username: ${{ github.actor }}
 password: ${{ secrets.GITHUB_TOKEN }}
 logout: false

 - name: Build optimized container with caching
 run: |
 REPO_LC=$(echo '${{ github.repository }}' | tr '[:upper:]' '[:lower:]') && \
 docker buildx build \
 --build-arg OTP_VERSION=${{ env.OTP_VERSION }} \
 --build-arg ELIXIR_VERSION=${{ env.ELIXIR_VERSION }} \
 --build-arg BASE_OTP_VERSION=${{ env.BASE_OTP_VERSION }} \
 --cache-from="type=registry,ref=ghcr.io/${REPO_LC}/builder-cache:latest" \
 --cache-to="type=registry,ref=ghcr.io/${REPO_LC}/builder-cache:latest,mode=max" \
 --load \
 -t amazon-linux-builder \
 -f Dockerfile.build .

 - name: Create artifact directory
 run: mkdir -p release_out

 - name: Build Phoenix Release with optimizations
 run: |
 docker run --rm \
 -v ${{ github.workspace }}:/app \
 -v $PWD/release_out:/app/release_out \
 -e MIX_ENV=${{ env.MIX_ENV }} \
 -e SECRET_KEY_BASE=${{ secrets.SECRET_KEY_BASE }} \
 -e RELEASE_COOKIE=${{ secrets.RELEASE_COOKIE }} \
 -e ELIXIR_ERL_OPTIONS="+fnu" \
 --workdir /app \
 amazon-linux-builder \
 /bin/bash -c "
 set -euo pipefail

 # Ensure release_out directory exists inside container
 mkdir -p /app/release_out

 echo 'Getting dependencies...'
 mix deps.get --only \${MIX_ENV}

 echo 'Compiling with optimizations...'
 # Compile with multiple jobs and optimizations
 MIX_ENV=\${MIX_ENV} mix compile --force --all-warnings

 echo 'Building release...'
 MIX_ENV=\${MIX_ENV} mix release --overwrite

 echo 'Packaging artifact...'
 tar -C _build/\${MIX_ENV}/rel/${{ env.APP_NAME }} -czf /app/release_out/${{ env.APP_NAME }}.tar.gz .

 echo 'Build complete!'
 "

 - name: Upload artifact
 uses: actions/upload-artifact@v4
 with:
 name: ${{ env.APP_NAME }}-x86-release
 path: release_out/${{ env.APP_NAME }}.tar.gz
 retention-days: 7

 outputs:
 app_name: ${{ env.APP_NAME }}

 deploy:
 name: Deploy to EC2
 runs-on: ubuntu-latest
 needs: build
 environment: prod
 if: github.ref == 'refs/heads/main'

 env:
 APP_NAME: "${{ needs.build.outputs.app_name }}"
 REMOTE_DIR: "/opt/${{ needs.build.outputs.app_name }}"
 SERVICE_NAME: "${{ needs.build.outputs.app_name }}"
 ENV_FILE: "/etc/${{ needs.build.outputs.app_name }}.env"

 steps:
 - name: Download artifact
 uses: actions/download-artifact@v4
 with:
 name: ${{ env.APP_NAME }}-x86-release
 path: .

 - name: Copy release to EC2
 uses: appleboy/scp-action@v0.1.7
 with:
 host: ${{ secrets.EC2_HOST }}
 username: ${{ secrets.EC2_USER }}
 key: ${{ secrets.EC2_SSH_KEY }}
 source: "${{ env.APP_NAME }}.tar.gz"
 target: "/tmp/"
 debug: true

 - name: Configure & restart service on EC2
 uses: appleboy/ssh-action@v1.0.3
 with:
 host: ${{ secrets.EC2_HOST }}
 username: ${{ secrets.EC2_USER }}
 key: ${{ secrets.EC2_SSH_KEY }}
 script: |
 set -euo pipefail

 APP_NAME="${{ env.APP_NAME }}"
 REMOTE_DIR="${{ env.REMOTE_DIR }}"
 SERVICE_NAME="${{ env.SERVICE_NAME }}"
 ENV_FILE="${{ env.ENV_FILE }}"
 TARBALL="/tmp/${APP_NAME}.tar.gz"

 # Create app directory and user if needed
 if ! id -u "$APP_NAME" >/dev/null 2>&1; then
 sudo useradd -r -s /bin/false -M "$APP_NAME"
 fi
 sudo mkdir -p "$REMOTE_DIR"
 sudo chown -R "$APP_NAME":"$APP_NAME" "$REMOTE_DIR"

 # Write/refresh environment file (runtime config)
 sudo bash -c "cat > $ENV_FILE" << 'EOF'
 MIX_ENV=prod
 PHX_SERVER=true
 PORT=${{ env.PHX_PORT }}
 PHX_HOST=${{ env.PHX_HOST }}
 SECRET_KEY_BASE=${SECRET_KEY_BASE}
 RELEASE_COOKIE=${RELEASE_COOKIE}
 ${{ secrets.ENV_VARS }}
 EOF

 # Substitute secrets into env file
 sudo sed -i "s|\${SECRET_KEY_BASE}|${{ secrets.SECRET_KEY_BASE }}|g" "$ENV_FILE"
 sudo sed -i "s|\${RELEASE_COOKIE}|${{ secrets.RELEASE_COOKIE }}|g" "$ENV_FILE"
 sudo sed -i "s|\${PHX_HOST}|${{ env.PHX_HOST || 'localhost' }}|g" "$ENV_FILE"
 sudo sed -i "s|\${PORT}|${{ env.PHX_PORT || '80' }}|g" "$ENV_FILE"

 # Lock down environment file
 sudo chown root:root "$ENV_FILE"
 sudo chmod 600 "$ENV_FILE"

 # Install or refresh systemd service
 SERVICE_FILE="/etc/systemd/system/${SERVICE_NAME}.service"
 sudo bash -c "cat > $SERVICE_FILE" << EOF
 [Unit]
 Description=${APP_NAME} Phoenix app
 After=network-online.target
 Wants=network-online.target

 [Service]
 Type=simple
 User=${APP_NAME}
 Group=${APP_NAME}
 EnvironmentFile=${ENV_FILE}
 WorkingDirectory=${REMOTE_DIR}
 ExecStart=${REMOTE_DIR}/bin/${APP_NAME} start
 ExecStop=${REMOTE_DIR}/bin/${APP_NAME} stop
 Restart=always
 RestartSec=5
 PrivateTmp=true
 LimitNOFILE=65536

 [Install]
 WantedBy=multi-user.target
 EOF

 sudo systemctl daemon-reload
 sudo systemctl enable "${SERVICE_NAME}"

 # Deploy new release
 TMP_DIR="$(mktemp -d)"
 sudo tar -C "$TMP_DIR" -xzf "$TARBALL"
 if [ -d "${REMOTE_DIR}/var" ]; then
 sudo rsync -a "${REMOTE_DIR}/var/" "${TMP_DIR}/var/" || true
 fi
 sudo rsync -a --delete "${TMP_DIR}/" "${REMOTE_DIR}/"
 sudo chown -R ${APP_NAME}:${APP_NAME} "${REMOTE_DIR}"

 # Clean old logs for a fresh journal view
 sudo systemctl stop "${SERVICE_NAME}"
 sudo journalctl --rotate
 sudo journalctl --vacuum-time=1s

 # Restart service with clean logs
 sudo systemctl start "${SERVICE_NAME}"
 sudo systemctl status "${SERVICE_NAME}" --no-pager -l || true

 echo "Deployment complete."

 # Log service status directly
 sudo journalctl -u "${SERVICE_NAME}" -n 20 --since "10 second ago"

Backyard Birds

blog@barrasso.me (Tom Barrasso) — Mon, 01 Sep 2025 00:00:00 GMT

Backyard Birds is an educational app created for the Yoto Player, a screen-free audio platform for kids. Backyard Birds brings the magic of birdwatching to children and families through personalized audio cards. The app uses AI (using OpenAI & Gemini) to write and narrate (using ElevanLabs) stories featuring birds recently sighted nearby, complete with authentic bird calls, interesting facts, and vibrant icons.

Backyard Birds was voted a Community Choice Winner in the Yoto 2025 Developer Challenge. Alongside Backyard Birds, I created another project, Fez the Cat, that delighted kids and parents alike with daily stories and letter-guessing games that test listening comprehension and spelling skills.

Tiny Screens, Big Impact: The Forgotten Art Of Developing Web Apps For Feature Phones

blog@barrasso.me (Tom Barrasso) — Wed, 16 Jul 2025 00:00:00 GMT

Learn why flip phones still matter in 2025, and how you can build and launch web apps for these tiny devices.

How PodLP Unlocks 3B+ Listeners Beyond Smartphones

blog@barrasso.me (Tom Barrasso) — Tue, 27 May 2025 00:00:00 GMT

PodcastingTech Show host Mathew Passy chats with Tom Barrasso, founder and developer of PodLP, the innovative app that brings podcasts to feature phones (“dumb phones”) around the world. If you’ve ever assumed your listeners all have iPhones or Androids, this episode will seriously open your eyes!

Remote Browsers and the Feature Phone Market with Tom Barrasso

blog@barrasso.me (Tom Barrasso) — Thu, 01 May 2025 00:00:00 GMT

Matt sits down with Tom Barrasso from Cloud Phone to explore why flip phones are still relevant in 2025. They discuss the rise of digital detox, who’s using feature phones today, and how developers can still build apps for low-spec devices. From KaiOS and Cloud Phone to nostalgia and screen-time reduction—this is a deep dive into the flip phone revival and the tech powering it.

Feature phones, remote browsers and connecting the next billion users

blog@barrasso.me (Tom Barrasso) — Wed, 23 Apr 2025 00:00:00 GMT

Explore the opportunities and challenges of building web applications for feature phones powered by remote Chromium browsers. Dive into what makes feature phones appealing in certain regions, how cloud-rendered browsers change the developer experience, and the practical aspects of working with these platforms from API support and navigation patterns to PWAs and future-facing capabilities.

Remote Browsers and the Feature Phone Market with Tom Barrasso

blog@barrasso.me (Tom Barrasso) — Wed, 09 Apr 2025 00:00:00 GMT

Explore the world of feature phones, how remote browsers make it possible to run modern apps on these low-end devices, and the unique challenges and opportunities for developers in this space.

Millions Could Be Using Your App on Flip Phones

blog@barrasso.me (Tom Barrasso) — Tue, 25 Mar 2025 00:00:00 GMT

In markets like India, sales of 4G feature phones are growing quickly as network operators transition from 2G to 4G & 5G. With just a few changes, your web app can be in the hands of millions on T9 feature phones.

Wasm on feature phones with Cloud Phone's Thomas Barrasso

blog@barrasso.me (Tom Barrasso) — Mon, 24 Mar 2025 00:00:00 GMT

Feature phones? Yes, they still make them. And they run Wasm! In this WasmAssembly podcast, Thomas Steiner hosts Thomas Barrasso from CloudMosa to talk about the Cloud Phone platform and what it takes to run WebAssembly on tiny feature phones by streaming Web apps from a remote server that runs Chromium.

Cloud Phone for Developers

blog@barrasso.me (Tom Barrasso) — Fri, 01 Nov 2024 00:00:00 GMT

Cloud Phone is a Chromium-based remote browser from CloudMosa, the company behind the Puffin browser. Cloud Phone lets users watch YouTube and TikTok on budget features phones with as little as 16MB RAM! As the Head of Developer Relations, I designed, authored, and built the Cloud Phone for Developers website, made guest appearances on podcasts, filmed and published content, developed reference applications, published TypeScript type declarations, and supported many Cloud Phone developers.

Cloud Phone for Developers is a static website generated using Hugo using a custom Doks-based theme and Algolia DocSearch. It’s continuously checked for typos and updated via GitHub Actions. Screenshots, code snippets, and resources are based on the feedback of developers from around the world including India, Nepal, Bangladesh, Pakistan, Vietnam, South Africa, and the United States.

Reference Applications #

Currency Converter #

I built open-source reference applications like a Currency Converter and Authenticator for time-based one-time passwords (OTP).

Authenticator #

Each reference application expands the app catalog with valuable utilities, while providing real-world codebases and tutorials to showcase a platform-specific user experience for developers.

Policy Zones

blog@barrasso.me (Tom Barrasso) — Sun, 01 Sep 2024 00:00:00 GMT

Get ready for the acronyms! As a Staff Technical Program Manager (TPM), I led the adoption of Privacy Aware Infrastructure (PAI) for privacy regulations like GDPR, DMA, CCPA, and ePD. I met with dozens of teams across Meta to pilot and scale information flow control (IFC) systems like Policy Zones to enforce flow restrictions at runtime. Programs I led ensured robust data protections across dozens of databases and processors at exabyte scale, including my principal domain focused on Artificial Intelligence (AI) data collection, model training, and inference serving systems.

Basically, I was a digital janitor making sure data was appropriately stored, processed, and deleted.

Vipaso

blog@barrasso.me (Tom Barrasso) — Wed, 01 May 2024 00:00:00 GMT

Vipaso provides secure mobile payments using Bluetooth Low Energy (BLE) to connect merchants and buyers without the need for expensive terminals or specialized hardware. I was contacted via KaiOS.dev to research and develop the Vipaso app for KaiOS. The app uses the Bluetooth Web API, a Firefox OS-specific predecessor to WebBluetooth API, to expose Generic Attribute Profile (GATT) services to discover payment intents.

Vipaso is a cross-platform payment app that supports payments on Bluetooth-enabled mobile devices running iOS, Android, or KaiOS.

CVE-2023-33293

blog@barrasso.me (Tom Barrasso) — Mon, 22 May 2023 00:00:00 GMT

A vulnerability (CVSS 5.3) in KaiOS 3.0 and 3.1 where the /system/kaios/api-daemon binary exposes a local web server on *.localhost with subdomains for each installed application, allowing attackers to determine which apps are installed and access their manifest.webmanifest contents.

CVE-2023-33294

blog@barrasso.me (Tom Barrasso) — Mon, 22 May 2023 00:00:00 GMT

A critical vulnerability (CVSS 9.8) in KaiOS 3.0 before 3.1 where the /system/bin/tctweb_server binary exposes an unprotected local web server on port 2929 that accepts and executes arbitrary Bash commands as root, accessible to all websites via the browser.

CVE-2023-27108

blog@barrasso.me (Tom Barrasso) — Thu, 23 Feb 2023 00:00:00 GMT

A vulnerability in KaiOS 3.0 where the pre-installed Communications application exposes a Web Activity that returns the user’s call log without origin or permission checks, enabling attackers to inject JavaScript code and transmit call logs to remote servers.

Amazon Pharmacy

blog@barrasso.me (Tom Barrasso) — Tue, 17 Nov 2020 00:00:00 GMT

As a Software Development Engineer (SDE), I built the real-time engine to calculate, collect, reconcile, and audit sales tax at PillPack and Amazon Pharmacy, part of the HIPAA covered entities for Amazon Health Services. As a Technical Program Manager (TPM), I led application security certification across many healthcare services. I led threat modeling, penetration testing (red teamimg), vulnerability triaging, incident response, and remediation.

Is podcasting ready for IPv6?

blog@barrasso.me (Tom Barrasso) — Thu, 10 Sep 2020 00:00:00 GMT

The world has been running out of IPv4 addresses for some time. Podcasting may not be prepared for the inevitable IPv6 future

Podcasts for the Next Billion

blog@barrasso.me (Tom Barrasso) — Wed, 24 Jun 2020 00:00:00 GMT

Designing a podcast client for KaiOS smart feature phones

PodLP

blog@barrasso.me (Tom Barrasso) — Wed, 01 Jan 2020 00:00:00 GMT

PodLP is the first and most popular podcast app for feature phones, available on KaiOS, the JioPhone, and Cloud Phone. With 10+ million installs across more than 175 countries, PodLP brings the podcast listening experience to the next billion listeners on affordable devices.

PodLP was a 2020 KaiOS Staff Pick, featured on Podnews, WBUR, and Sounds Profitable. Users find PodLP easy to use and one of most useful apps. You can also listen to podcasts discussing PodLP including Buzzcast, Svelte Society, and Podcasting Tech.

Labs & Libraries #

PodLP has branched out into experiments like PodCal, a tool to subscribe to podcasts in your calendar app, an NPM package to parse RSS feeds called podparse, and feature suggestions for the Podcast Index XML namespace.

Alongside PodLP, I authored KaiOS.dev to share lessons from 5+ years of experience building, launching, and scaling apps on feature phones. I also built KaiOS.app providing public landing pages with screenshots, and on KaiOS, each page launches the app details page on the KaiStore or JioStore using Web Activities. Both websites are open source on GitHub (kaios-dev-blog and kaios-app), alongside my NPM package kaios-types offering TypeScript type declarations for dozens of non-standard APIs.

Why does JavaScript have -0?

blog@barrasso.me (Tom Barrasso) — Tue, 03 Dec 2019 00:00:00 GMT

Why so negative zero? JavaScript has two zeroes and they’re both the same and different

Scale Securely with Transit Gateway

blog@barrasso.me (Tom Barrasso) — Mon, 02 Dec 2019 00:00:00 GMT

AWS Transit Gateway provides secure and scalable cloud connectivity to on-premise networks

Totally legit software methodologies

blog@barrasso.me (Tom Barrasso) — Mon, 14 Oct 2019 00:00:00 GMT

Instagram Driven Development, and other commonly employed strategies for crafting digital experiences

Why RSpec Tests Fail (and How To Fix Them)

blog@barrasso.me (Tom Barrasso) — Mon, 07 Oct 2019 00:00:00 GMT

Knowing how to troubleshoot tests is an essential software skill

A practical guide to ES6 Proxy

blog@barrasso.me (Tom Barrasso) — Thu, 16 May 2019 00:00:00 GMT

Proxies on proxies for clean and composable Javascript metaprogramming

A practical guide to ES6 Symbol

blog@barrasso.me (Tom Barrasso) — Mon, 13 May 2019 00:00:00 GMT

Practical Javascript metaprogramming with Symbols

thank u, [Symbol.iterator].next

blog@barrasso.me (Tom Barrasso) — Wed, 10 Apr 2019 00:00:00 GMT

I’m so f****in’ grateful for this spec. Modular iteration without cloning or modifying in-place

The first shall be last with JavaScript arrays

blog@barrasso.me (Tom Barrasso) — Thu, 28 Mar 2019 00:00:00 GMT

So the last shall be [0], and the first [length - 1]

Dear Javascript,

blog@barrasso.me (Tom Barrasso) — Fri, 08 Feb 2019 00:00:00 GMT

this isn’t working.

How to Learn Elixir for Hipster Javascript Developers

blog@barrasso.me (Tom Barrasso) — Tue, 05 Feb 2019 00:00:00 GMT

Everyone knows Javascript. Your grandma, father-in-law, old college roommate… even your cat knows Javascript!

Hello, Elixir — The First Month

blog@barrasso.me (Tom Barrasso) — Thu, 10 Jan 2019 00:00:00 GMT

I’ve used Elixir for a month and mostly like it

John Hancock Investments

blog@barrasso.me (Tom Barrasso) — Mon, 10 Sep 2018 00:00:00 GMT

I led the front-end team launching the redesigned John Hancock Investments website, including the interactive Fund Compare tool. Complex financial data was rendered precisely using custom Plotly charts and dynamic SVGs. Downloadable Fact Sheets were rendered using Puppeteer to month and quarter-end PDFs. I collaborated with our backend team, often landing backend changes in Adobe Experience Manager (AEM) to ensure a timely and pixel-perfect delivery for our client.

Animated React Metaballs

blog@barrasso.me (Tom Barrasso) — Wed, 01 Aug 2018 00:00:00 GMT

React component for animated SVG metaballs

Basics of Text Analysis & Visualization

blog@barrasso.me (Tom Barrasso) — Tue, 24 Jul 2018 00:00:00 GMT

Bigram cloud and sentiment analysis applied to GitHub READMEs

Open Source Words — Part 2

blog@barrasso.me (Tom Barrasso) — Mon, 16 Jul 2018 00:00:00 GMT

There are many words used to describe software: framework, progressive, modular, reusable, extensible, scalable, simple, ad infinitum…

Open Source Words — Part 1

blog@barrasso.me (Tom Barrasso) — Sun, 15 Jul 2018 00:00:00 GMT

I set out to understand words used to describe software, and in particular, open source software. What words form the collective developer…

HTML Overlays in Plotly.js

blog@barrasso.me (Tom Barrasso) — Tue, 03 Jul 2018 00:00:00 GMT

I’ve talked about several features and limitations of Plotly.js before. It’s a very capable framework but I’ve found a number of important…

Resumes in HTML, CSS, and JS

blog@barrasso.me (Tom Barrasso) — Fri, 29 Jun 2018 00:00:00 GMT

There’s lots of guides on how to write a resume as a developer, but very few resources for actually creating one. Google for “resume…

Quick Start with HTML Template Language on Adobe Experience Manager

blog@barrasso.me (Tom Barrasso) — Wed, 07 Mar 2018 00:00:00 GMT

Introduction

Plotly Tip #6: positioning axis titles in horizontal bar chart

blog@barrasso.me (Tom Barrasso) — Mon, 26 Feb 2018 00:00:00 GMT

About Plot.ly

Plotly Tip #5: sand charts

blog@barrasso.me (Tom Barrasso) — Tue, 06 Feb 2018 00:00:00 GMT

About Plot.ly

Plotly Tip #4: text outlines

blog@barrasso.me (Tom Barrasso) — Fri, 02 Feb 2018 00:00:00 GMT

About Plot.ly

Plotly Tip #3: Custom Legends

blog@barrasso.me (Tom Barrasso) — Wed, 24 Jan 2018 00:00:00 GMT

About Plot.ly

Plotly Tip #2: SVG & z-index

blog@barrasso.me (Tom Barrasso) — Tue, 23 Jan 2018 00:00:00 GMT

About Plot.ly

Plotly Tip #1: dtick

blog@barrasso.me (Tom Barrasso) — Mon, 22 Jan 2018 00:00:00 GMT

About Plot.ly

How Many Ways To Say, Unsubscribe

blog@barrasso.me (Tom Barrasso) — Fri, 12 Jan 2018 00:00:00 GMT

I’ve recently been purging spam in my inbox.

Drag & Drop using CSS Transforms

blog@barrasso.me (Tom Barrasso) — Mon, 08 Jan 2018 00:00:00 GMT

Perhaps one of the most common features of modern web applications is the ability to drag (and sometimes drop or sort) elements. So common…

On The "Broken Image Icon"

blog@barrasso.me (Tom Barrasso) — Wed, 03 Jan 2018 00:00:00 GMT

A while ago I got to wondering if it is possible to style the broken image icon. As it turns out, aside from Firefox’s…

Keeping current with CSS currentColor

blog@barrasso.me (Tom Barrasso) — Mon, 01 Jan 2018 00:00:00 GMT

If you’re familiar with Sass or LESS then you’re apt to use preprocessor variables to parameterize the dimensions and colors of a site…

How I wish new password fields worked

blog@barrasso.me (Tom Barrasso) — Sat, 30 Dec 2017 00:00:00 GMT

For a recent project I was tasked with implementing client-side login & registration forms. The flow was quite complex because it involved…

Advanced meta-Metaballs

blog@barrasso.me (Tom Barrasso) — Fri, 29 Dec 2017 00:00:00 GMT

Building on my last article, Pretty Metaballs, I have seen a number of metaball examples that connect two circles, or that do so in a…

Pretty SVG Metaballs

blog@barrasso.me (Tom Barrasso) — Wed, 20 Dec 2017 00:00:00 GMT

Metaballs (not meatballs), like the ones below, are circles with overlapping areas proportional to their size and proximity.

Noyze

blog@barrasso.me (Tom Barrasso) — Wed, 01 Oct 2014 00:00:00 GMT

Noyze was the first volume panel replacement app for Android. Leveraging the new AccessibilityService API, Noyze could override how the system responds to volume buttons, providing a themed extensive with endless customization options. Noyze added playback and multi-channel controls, along with the ability to launch apps by long pressing volume up or down.

With more than 500,000+ installs, Noyze was featured on Gadget Hacks, Android Police, PhoneArena, and was one of Computerworld’s favorite apps for October 2014.

Themes #

A key feature of Noyze was the extensive catalog of customizable themes designed to mirror modern and nostalgic styles, from the minimalistic status bar theme to multi-channel controls. Extensive research was done across a variety of systems and interfaces to understand which designs and features resonated most with users.

reClock

blog@barrasso.me (Tom Barrasso) — Mon, 24 Feb 2014 00:00:00 GMT

reClock was a small experiment developed in collaboration with Graham Macphee, designed to be the minimalist clock widget that you actually have to read. Attention is in short supply and this often leads to a form of amnesia where you forget what you just read. reClock used random offsets to indicate the time in a format like “six until twelve twenty five” or “quarter past nine o’two.”

Although simple, reClock presented a challenge both in human psychology and efficient rasterization. At the time, JobScheduler was not available and the simplest (but less efficient) way to render a widget was to run a background service. reClock pre-rendered several updates for each minute until the countdown occurred, and called AppWidgetManager to cycle through renders.

PlanGrid

blog@barrasso.me (Tom Barrasso) — Mon, 10 Jun 2013 00:00:00 GMT

After releasing several notable Android apps including StatusBar+ and ChargeBar, I was contacted in 2012 by PlanGrid to develop the first version of their blueprint reader for Android tablets. At this time, the Android ecosystem was nascent, fragmented, and unstable. I developed several components including GridFragment and a tile rendering engine to display high-fidelity blueprints on resource-constrained devices (similar to TileView).

Android Studio wasn’t officially released until December 2014, so early versions of PlanGrid for Android used Ant, Eclipse, and integrated with Bugsnag for crash detection. PlanGrid for Android Beta (v0.1.1) was publicly released in February 2014

ChargeBar

blog@barrasso.me (Tom Barrasso) — Sun, 19 Feb 2012 00:00:00 GMT

Inspired by early designs from Xaiomi’s custom Android ROM, MIUI, ChargeBar added a thin line on top of your status bar indicating battery charge. ChargeBar surpassed 500,000+ installs and was featured on the likes of Life Hacker, Redmond Pie, and Droid Life.

ChargeBar was sold on Apptopia (later Fliptopia) in 2012, a marketplace to buy and sell apps.

StatusBar+

blog@barrasso.me (Tom Barrasso) — Wed, 14 Sep 2011 00:00:00 GMT

Launched in September 2011, StatusBar+ was the first Android app that I published, achieving 500,000+ installs. It was also Android’s first status bar replacement app that didn’t require jailbreaking or root access! StatusBar+ used the WindowManager API to draw on top of the system status bar. Originally themed like Windows Phone 7, StatusBar+ expanded to offer many more features and themes. StatusBar+ was eventually sold on Apptopia (later Fliptopia) in 2012, a marketplace to buy and sell apps.

Check out the video above where Marques Brownlee of MKBHD reviewed a very early version of StatusBar+ on the original Motorola Droid.

TextMyFood

blog@barrasso.me (Tom Barrasso) — Tue, 01 Jun 2010 00:00:00 GMT

For an internship I developed a prototype of TextMyFood, a Ruby on Rails service integrated with Twilio to let restaurant customers text their waiter to request another round of beer, a new fork, the check, whatever. A decade before the COVID-19 pandemic made QR code menus ubiquitous, TextMyFood was piloted at Charlie’s Kitchen in Cambridge, MA in an attempt to balance lax vs overly-attentive service using simple, readily-available technology.

TextMyFood was featured news websites including NPR, the Boston Herald, and the Boston Phoenix.

Digital Independence

blog@barrasso.me (Tom Barrasso) — Tue, 15 Dec 2009 00:00:00 GMT

As part of Ashoka Youth Venture, I co-founded the non-profit, Digital Independence, in 2009 alongside Bandhan Zishanuzzaman and Arjun Agarwala. Our mission was to educate and empower Boston residents through free computer literacy courses, and to reduce electronic waste (e-waste) by offering discounted computer repair services.

We repaired, upgraded, and donated hundreds of desktops, laptops, and smartphones. In both 2010 and 2011, we received the “Best of the Best” award from the Mayor’s Summer Youth Employment Program (MYSEP) where we employed and managed nearly a dozen high school students in Cambridge, MA each summer.

Home - Tom Barrasso

Introducing iClaw, a safe, private, on-device AI agent using Apple Intelligence

Why Build iClaw? #

What can iClaw do? #

What could iClaw do? #

Why On-Device? #

Local Tradeoffs #

What about other models? #

What I Learned #

1. Just a few tools #

2. No context snowballs #

3. Lower your expectations #

4. Other lessons #

Nested choices #

Arithmetic and hallucinations #

Don’t pollute the context #

Rewind the tapes #

Tactical advice #

What’s Next? #

Deterministic text-to-bash with ShellTalk

Why no LLMs? #

How ShellTalk works #

Testing ShellTalk #

Limitations #

What’s Next? #

Building an on-device Swift coding agent using Apple Intelligence

What is Junco? #

Why build Junco? #

Why fully local? #

Why not use OpenCode? #

Junco at a glance #

Lessons & Limitations #

Ask not what your model can do for you #

One thing at a time #

Happy little trees #

Teach a model how to fish #

Fewer guardrails #

Count your tokens #

Stochastic Parroting #

Model of the week #

What’s Next? #

Why Dumbphone Apps Are So Hard to Build

6 lessons from 6 years building software for flip phones

1. Leave the crowds #

2. The riches are (still) in the niches #

3. Stick with it #

4. The power of “Wow!” #

5. Technical lesson: memory matters #

6. It only gets easier #

Closing thoughts #

Quickly reverse engineer hidden Android APIs with Gemini and OpenCode

Why Reverse Engineer an APK? #

Reverse Engineering Tools #

Why Now? #

Reverse Engineering in OpenCode #

Part 2. Sonim and Beyond #

Conclusion #

Migrating PodLP from JavaScript to TypeScript using OpenCode

At a Glance #

Background and Motivation #

But First, A Types Library #

Aside: webidl2ts #

Now With More Logic #

Testing #

Results #

Reflections on a year abroad

Aotearoa New Zealand 🇳🇿 #

The next chapter: rest of world #

Australia 🇦🇺 #

Vietnam 🇻🇳 #

Thailand 🇹🇭 #

India 🇮🇳 #

Europe #

Switzerland 🇨🇭 #

Italy 🇮🇹 #

Romania 🇷🇴 #

Cyprus 🇨🇾 #

Türkiye 🇹🇷 #

Returning Home #

Rotating content daily with Cloudfront Functions

Aside: `webidl2ts` #

`tmpfs` Missteps #