Teaching Codex to Poke My Phone

There is a particular kind of software irritation where the feature you need exists, the app supports it, and the integration you are using has apparently never heard of it.

You can see the button on your phone. You just have to personally supply the finger.

That is the sort of gap android-phone-control is meant to handle. It is a Codex skill with a small Python helper for operating Android apps over a paired ADB connection. It can inspect the interface, capture screenshots, tap controls, swipe, and enter text.

This also fits a habit I am trying to build: when something useful comes out of a Codex session, turn it into a skill while the details are still available.

There is a reasonable argument that this is AI slop. Fair enough. I would at least like my slop to come with a README and be useful a second time.

I am still a little skeptical of the whole agent-skills thing. We have reached the point where putting instructions in a folder gets a product category. Somewhere, a shell script with a README is wondering why nobody ever invited it to a conference.

Still, a surprising amount of the value in these sessions lives in the annoying details. Which command worked. Which control was actually editable. Which apparent success turned out to mean almost nothing. Leave all of that in a chat history and the next attempt becomes an archaeological project.

Putting it into a skill gives the next session somewhere better to start.

For this one, the operating loop is straightforward: inspect the current screen, identify the intended control, perform an action, and inspect what happened.

The helper requires an explicit device and app package. It captures fresh UI state before making changes and rejects ambiguous matches. Text entry checks the field’s current contents before replacing them. Screenshots help with controls that the UI hierarchy does not describe properly.

These details become useful very quickly when an app presents several controls with the same label, changes screens unexpectedly, or decides a notification belongs directly over the thing you were about to press.

The phone has its own plans.

Any.do provides a good example of why this exists. Its connected tools can handle tasks, notes, and subtasks, while some reminder and priority controls need the mobile interface. The repository includes notes on those mobile workflows, including location reminders and the differences between ordinary tasks and Smart Grocery List items.

It also documents the small administrative ceremony involved in saving things. Depending on the screen, you may select a place, choose Arrive, press Set, save the reminder, and then save the task.

Apparently the first Save was an opening statement.

That makes verification a substantial part of the skill. A tap can succeed while the requested change remains unsaved. The workflow calls for reopening the edited item and checking the actual values.

Even then, a saved location reminder and a notification that has successfully fired are separate things to verify. There is also no configurable radius in the Any.do editor documented here. Putting “500 metres” in a location name would produce a very specific label and exactly zero additional geofencing capability.

I want those limitations written down alongside the working steps. They are useful knowledge too.

The same applies when a connection drops during an action. The helper leaves a private action record, and the workflow calls for inspecting the app before trying again. Repeating an uncertain action is an excellent way to turn one confusing task into two confusing tasks.

Getting started requires Python, Android Platform Tools, and pairing the phone for wireless debugging. The repo includes the setup instructions. Screenshots and runtime records stay outside the checkout, so the reusable part can be shared without bringing someone’s phone contents along.

The broader experiment is getting consistent about preserving this kind of work. Solve a problem, capture the procedure, include the awkward bits, and improve it when reality supplies another correction.

Over time, I would like a collection of small skills that reflect things I actually do. Each one should save some rediscovery and give Codex a clearer account of what working looks like.

This entry happens to involve an Android phone and several opportunities to misunderstand a Save button.

Seems like a reasonable place to start.

The code, skill, and installation instructions are on GitHub: nigeldaniels/android-phone-control.

ROS2 OSX brew formula

Featured

Getting ROS 2 Working on macOS, Then Packaging It for Homebrew

ROS 2 on macOS is one of those things that technically works, but often feels harder than it should. The official source-build path is real, but in practice it can turn into a long chain of dependency issues, middleware decisions, Python problems, Qt mismatches, and package combinations that work on one machine but not another.

I wanted a better answer than “it builds on my laptop.” The goal was to get ROS 2 running reliably on macOS, verify the tools people actually use in the beginner tutorials and early development workflows, and package the result so other developers could install it with Homebrew instead of rebuilding the whole stack from scratch.

That work is now complete. The result is a Homebrew-installable formula called ros2-kilted-core: a tested, curated ROS 2 Kilted environment for macOS.

The problem

ROS 2 is well supported on Linux. On macOS, the story is less polished.

The source-build path exists, but it is easy to end up in a state where the build partially succeeds, some tools launch, others fail, and the final setup is too fragile to recommend to anyone else. A successful compile is not the same thing as a usable development environment.

That was the real problem to solve: not just making ROS 2 build once, but making it practical.

That meant getting the core runtime working, verifying the tools used in the beginner tutorials, making sure the GUI tools actually launched, and confirming that the result could support real development instead of merely surviving a single build command.

What I built

This project started with a source checkout of ROS 2 Kilted on macOS and a curated build of the packages needed for a realistic developer workflow.

That included:

  • building the core ROS 2 runtime on macOS
  • standardizing on Fast DDS as the default supported middleware path
  • verifying demo talker/listener nodes
  • getting turtlesim working
  • validating the beginner CLI tools, including:
    • ros2 node
    • ros2 topic
    • ros2 service
    • ros2 action
    • ros2 param
    • ros2 interface
    • ros2 launch
    • ros2 doctor
    • ros2 bag
  • getting rqt_graph, rqt_console, and rqt_service_caller working on macOS
  • creating a separate tutorial workspace for beginner client-library examples
  • packaging the result into a Homebrew formula

The result is not a theoretical “this should probably work” setup. It is a tested ROS 2 environment for macOS, built from source and packaged for reuse.

The macOS-specific work

A large part of the effort was in solving the smaller platform-specific issues that tend to make ROS 2 on macOS feel unreliable.

That included:

  • choosing a package set broad enough to be useful but small enough to maintain realistically on macOS
  • narrowing the middleware path so runtime behavior stayed predictable
  • handling Python and Qt GUI dependencies cleanly
  • fixing a Qt5/Qt6 header clash affecting turtlesim
  • patching the rqt path so it used a working PyQt setup on macOS
  • dealing with vendor packages that would otherwise try to download sources during the build
  • bundling Python build and runtime tooling in a reproducible way
  • validating the final result outside the original development workspace

In other words, this was less about running one successful build command and more about taking a fragile source build and turning it into a repeatable installation.

What the Homebrew formula installs

The Homebrew formula is called ros2-kilted-core.

It installs a curated ROS 2 macOS build that includes:

  • the core ROS 2 runtime
  • Fast DDS as the supported default RMW path
  • the main ROS 2 CLI tools
  • turtlesim
  • rqt_graph
  • rqt_console
  • rqt_service_caller
  • ros2 bag
  • the rest of the validated beginner and developer toolchain

It is intentionally not a full “everything in ROS 2” desktop distribution. It is a curated macOS-focused build designed to be practical for tutorials and development.

The main benefit is that users do not need to manually clone the source workspace, run vcs import, assemble the Python build environment, or rediscover the same macOS-specific fixes. Homebrew downloads the packaged source bundle and builds from that.

Why I packaged this as a custom Homebrew tap

I packaged this as a custom Homebrew tap rather than submitting it to homebrew/core.

That was the right fit for a few reasons:

  • it is a curated ROS 2 distribution, not a tiny standalone utility
  • it is specifically tuned for macOS
  • it includes a practical set of development and tutorial tools
  • it is easier to maintain and iterate in a dedicated tap than in the main Homebrew formula collection

That means the package is installable through Homebrew, but maintained in its own GitHub repository.

Installation

The Homebrew tap is here:

nigeldaniels/homebrew-ros2-kilted

Install it with:

brew install nigeldaniels/ros2-kilted/ros2-kilted-core

The package uses ros2-kilted-prefixed commands instead of replacing the global ros2 command, which makes it safer to install alongside other ROS environments.

Why this matters

A lot of developers want to experiment with ROS 2 on macOS, work through the tutorials, or do real development without switching to Linux immediately. The source-build path exists, but it is still rough enough that many people give up before they get to the interesting part.

This project makes that path much more approachable.

Instead of “it should work if everything goes right,” the result is now:

  • a working ROS 2 source build on macOS
  • a verified set of beginner and development tools
  • a reusable Homebrew installation path for other developers

That makes ROS 2 on macOS far more practical than it was before.

Final thoughts

ROS 2 on macOS is still not the smoothest platform story in robotics, but it becomes much more usable once the setup is curated, tested, and packaged properly.

That was the point of this work: get ROS 2 working on macOS, make sure the important tooling actually runs, and package it so other developers can install it without repeating the same setup process by hand.

If this saves someone else from spending a weekend chasing build failures, Python issues, middleware confusion, and Qt breakage, then it was worth doing.

movie screeners 2014

So for at least the last 10-12 years I have noticed that around this time of year “screeners” for various movies start to become available on various torrent  or newsgroup websites. I assume this is in anticipation for the oscars.

A screener for the uninitiated is a DVD release made for members of the Academy so they are able to judge movies for the oscars. Why they can’t be bothered to see them in theaters like every one else I will never know.

This year I have decided to compile of short list of the ones that I see. Follow the links and download files at your own risk. I can however verify that all the links provided are to genuine DVD or blue ray screeners for movies which are currently only available in theaters. These are not telesyncs , CAMS or anything else.

I chose to only provide links to publicly accessible torrent sites to make things easier for every one. If you do choose to download something please use at least a browser based adblocker and take the appropriate security measures.

oscar

Enjoy !

The Z

So a few years ago a buddy of mine and I bought a 1974 240z to just drive around like idiots.

The Car only cost 1200 dollars. and the Idea was to drive the thing around in the desert and just have a good time.

We live in the East SF Bayarea and the car was located in Santa Cruz. We sorta decided to buy the car on a whim and ended up in santa Cruz at night ( Never buy a car at night !). We took a cursory look and things looked good. The car only cost 1200 dollars so we were not expecting much more than being able to drive the car. I took it for a test drive and man it pulled like a monster in 3rd gear.

The Drive Home.

This is when things started to go down hill. First I noticed the car had no mirrors not a huge deal, but I certainly would have noticed this if we had not bought the car at night.

If you have ever driven down  to santa cruz its a great drive however driving a 1200 dollar car down the 17 at night with no mirrors is to say the least an experience. Then I noticed I was getting a bit dizzy thanks to exhaust leaking into the car.

We did eventually make it home but as we entered the driveway the engine showed signs of over heating.

Anyways the car ended up needing alot of work I think I will post about that  another time.

ZIMG_7191

Land Sailor

So my buddy and I built a ” land sailor”.  We got the idea after making a trip to home depot to just wonder around. My friend noticed a roll of tyvek and said ” it would work well for making sails”.

We ended up not making the sails from tyvek instead we purchased a used sunfish on craigslist

Image

And so the land sailor born

land sailor

It broke during the first ride after my buddy drove it into a hole