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.

Learning LangGraph by Breaking My RF Agent Graph ALOT!

A couple of weeks ago my RF agent had a very simple LangGraph.
It looked roughly like this: The graph you see bellow was sufficant along with a long list of DSP tools to do the fallowing 2 experiments:

At the time, this seemed almost trivial.

The model receives the conversation. If it wants to use one of the RF-analysis tools, LangGraph sends the requested tool call to call_tools. The tool result comes back to the model, the model reasons about the result, and eventually it produces an answer without requesting another tool.

In code, the important shape was basically:

builder.add_node("call_model", self.call_model)
builder.add_node("call_tools", ToolNode(
available_tools,
handle_tool_errors=True,
wrap_tool_call=self.state_updater.update,
awrap_tool_call=self.state_updater.update_async,
))
builder.add_edge(START, "call_model")
builder.add_conditional_edges("call_model", ...)
builder.add_edge("call_tools", "call_model")

The line I did not fully appreciate yet was:

builder.add_edge("call_tools", "call_model")

That isn’t just a convenient loop.

It is the basic tool-calling protocol. Used by nearly all simple AI agents today

The model asks for a tool. The tool runs. The resulting ToolMessage has to go back to the model so the model can see what happened.

That part of my original graph was actually right.

I Added the Idea of an RF Survey

The RF agent was becoming more than a collection of analysis tools.

I wanted to be able to say something like:

Survey 70mhz – 1ghz and find anything intresting

A survey has state that ordinary one-off analysis doesn’t necessarily have.

For example, I wanted to create a survey ID and a directory where captures belonging to that survey could be stored. A survey can span multiple IQ and SigMF files

So I added an init_survey node.

The node itself was extremely simple:

def init_survey(self, state: RFState):
survey_id = str(uuid4())
survey_dir = os.getcwd() + "/" + survey_id
if not os.path.exists(survey_dir):
os.makedirs(survey_dir)
print(f"Survey ID: {survey_id}")
print(f"Survey Dir: {survey_dir}")
return {
"survey": {
"survey_id": survey_id,
"survey_dir": survey_dir,
}

There wasn’t really anything mysterious about this code.

The difficult part was figuring out where this operation belonged in the graph.And that turned into a much better LangGraph lesson than I expected.

Mistake #1: Treating Survey Routing Like Model Routing. My first instinct was to bolt survey detection onto the graph I already had.

Something along these lines:

builder.add_edge(START, "call_model")
builder.add_conditional_edges(
"call_model",
self.is_survey,
self.control_map,
)
This was the routing function
@staticmethod
def is_survey(state: RFState) -> Literal["survey", "model"]:
select = state["messages"][-1]
if isinstance(select, HumanMessage) and "survey" in str(select.content).lower():
return "survey"
return "model"

This is the “pathmap” I called it self.control_map

sefl.control_map = {
"tools": "call_tools",
"survey": "init_survey",
"model": "call_model",
END: END,
}

resulting graph …. Thats not right!

The model runs, then some routing function determines whether we’re doing a survey, calling tools, continuing through the model, or ending.

The problem was subtle but fundamental:

is_survey() was being called after call_model.

At that point the latest message was no longer necessarily the human request.

It was an AIMessage.

I was trying to use one router to answer two completely different questions:

  1. What kind of request did the human make?
  2. What should happen after the model responds?

Those are not the same routing decision.And they don’t even operate on the same kind of message.

Mistake #2

At this point I tried to fix the design by moving survey detection to the beginning of the graph, but I only fixed half of the problem. I added a smaller SURVEY_MAP at START, where is_survey() actually made sense because the latest message was still the user’s HumanMessage. But I also left that same is_survey() router attached to call_model and reused the larger CONTROL_MAP. That is what produced the graph above. After call_model ran, the newest message was an AIMessage, so is_survey() could no longer recognize it as a survey request and simply returned "model". The control map then sent "model" straight back to call_model, creating the self-loop. The visualization also showed tools, survey, model, and END as possible post-model routes because they were all present in CONTROL_MAP, even though is_survey() wasn’t really the right function to make all of those decisions. I had started separating the two kinds of routing, but I was still using the same router in both places.

The routing function itself was:

@staticmethod
def is_survey(state: RFState) -> Literal["survey", "model"]:
select = state["messages"][-1]
if isinstance(select, HumanMessage) and "survey" in str(select.content).lower():
return "survey"
return "model"

Pathmaps + new edges:

self.control_map = {
"tools": "call_tools",
"survey": "init_survey",
"model": "call_model",
END: END,
}
self.survey_map = {
"survey": "init_survey",
"model": "call_model",
}

The Mistake Was essentially:

builder.add_conditional_edges(
START,
self.is_survey,
SURVEY_MAP,
)
builder.add_conditional_edges(
"call_model",
self.is_survey,
self.control_map,
)
builder.add_edge("call_tools", END)
builder.add_edge("init_survey", END)

Once call_model had produced an AIMessage, the HumanMessage check failed, "model" was returned, and the graph sent itself right back into call_model. The resulting graph looks like this:

The important thing is that the graph looked like it had several possible routes, but at runtime it behaved much more simply—and much worse.

For a normal request, START called is_survey(). If the user’s message didn’t contain "survey", it returned "model", which correctly sent execution to call_model. The model then generated an AIMessage. But after that, I called is_survey() again. Since the newest message was now an AIMessage, this check could never succeed:

Mistake #3

To correct that, I separated the two routing decisions. Survey detection moved to START, where is_survey() could still inspect the original HumanMessage and decide whether the request should enter the survey path or the normal model path. After call_model, I used a different router whose job was only to inspect the model’s response and decide whether it had requested a tool or was finished. The goal was to eliminate the accidental call_model -> call_model loop by making each router responsible for one kind of decision. That part was the right idea, but in trying to make the graph terminate cleanly I went too far and routed call_tools directly to END, which introduced the next problem.

code: You will have to excuse the switch from pathmaps maps as class variables to constants

# First router:
# This now runs at START, while the latest message is still
# the user's HumanMessage.
@staticmethod
def is_survey(state: RFState) -> Literal["survey", "model"]:
select = state["messages"][-1]
if isinstance(select, HumanMessage) and "survey" in str(select.content).lower():
return "survey"
return "model"
# Second router:
# This runs after call_model and asks a completely different question:
# did the model request a tool, or is it finished?
@staticmethod
def after_model(state: RFState) -> Literal["tools", "__end__"]:
select = state["messages"][-1]
if select.tool_calls:
return "tools"
return END
# Routing at START is now only about the user's intent.
SURVEY_MAP = {
"survey": "init_survey",
"model": "call_model",
}
# Routing after call_model is now only about the model's response.
CONTROL_MAP = {
"tools": "call_tools",
END: END,
}
# The two routing decisions are finally separated.
builder.add_conditional_edges(
START,
self.is_survey,
SURVEY_MAP,
)
builder.add_conditional_edges(
"call_model",
self.after_model,
CONTROL_MAP,
)
# This was the remaining mistake:
# after running a tool, we ended the graph instead of
# returning the ToolMessage to call_model.
builder.add_edge("call_tools", END)
builder.add_edge("init_survey", END)

Resulting Still incorrect graph

This Fallowing is how I finally fixed it.

The final fix was to keep the routing responsibilities separated and restore the tool loop that I had accidentally removed. is_survey() stayed at START, where it only decides whether the original HumanMessage should begin a survey or go through the normal model path. After call_model, a different router looks at the resulting AIMessage: if the model requested a tool, execution goes to call_tools; if it did not, the graph is done and goes to END. The crucial change was replacing call_tools -> END with call_tools -> call_model. Now a tool can run, add its ToolMessage result to state, and return control to the model so it can reason about that new information, request another tool if necessary, or finish. That gives us the graph we have now: survey routing happens once at the beginning, while the model and tools form a deliberate reasoning loop that only ends when the model no longer asks for another tool.

# Route the original user request before the model runs.
@staticmethod
def is_survey(state: RFState) -> Literal["survey", "model"]:
select = state["messages"][-1]
if isinstance(select, HumanMessage) and "survey" in str(select.content).lower():
return "survey"
return "model"
# Route the model's response after call_model runs.
@staticmethod
def after_model(state: RFState) -> Literal["tools", "done"]:
select = state["messages"][-1]
if select.tool_calls:
return "tools"
return "done"
# Entry routing: user intent only.
SURVEY_MAP = {
"survey": "init_survey",
"model": "call_model",
}
# Post-model routing: model behavior only.
CONTROL_MAP = {
"tools": "call_tools",
"done": END,
}
builder.add_conditional_edges(
START,
self.is_survey,
SURVEY_MAP,
)
builder.add_conditional_edges(
"call_model",
self.after_model,
CONTROL_MAP,
)
# Tool results go back to the model so it can reason about them.
builder.add_edge("call_tools", "call_model")
# Survey initialization currently ends here.
builder.add_edge("init_survey", END)

The resulting graph: Correct !

The funny part is that after all of this, the RF agent still does not actually perform a survey yet. init_survey only creates the survey state and gives the graph somewhere to enter that workflow. But getting that one node into the graph correctly forced me to understand a lot more about how LangGraph control flow actually works: where user intent should be classified, how model responses should be routed, and why tool execution has to feed results back into the model. It was a surprising amount of work just to add one node, but that work created the place where the real survey logic can now begin. From here, I can start designing the agentic part of the survey itself: choosing frequencies, bandwidth, dwell time, deciding when to capture IQ, reacting to what the analysis finds, and eventually letting the agent decide what measurement is worth taking next.

First Agentic analysis of basically unknown signal from capture to characterization.

RF Agent at Work: Characterizing an Unknown 300 MHz Signal

I wanted to see how far the RF agent could get characterizing a real transmission using only the tools currently available to it.

The target device had FCC ID 2BFDR-RQBK6.

I intentionally restricted the agent at the beginning. It was allowed to determine only the transmit frequency, and it was specifically instructed not to investigate any other RF characteristics or begin capturing until told to do so.


Finding the Frequency

Me:

> Hi, we’re going to start capture of FCC ID 2BFDR-RQBK6. The only thing I want you to find out about that device is the frequency it transmits at. DO NOT get any other RF information about that device, and do not start capturing until I tell you.

RF Agent:

> Understood. I’ll only determine the device’s transmit frequency, no other RF characteristics, and I will not start any capture until you explicitly tell me to. No action has been taken.

Me:

> What frequency does it transmit at?

RF Agent:

> I can’t reliably verify the transmit frequency from the FCC ID alone. The ID does not encode it, and I don’t have the FCC filing available here. I won’t guess or start a capture. > > If you provide the FCC grant/exhibit for 2BFDR-RQBK6, I’ll extract only the authorized transmit frequency or frequency range.

Me:

> Can you look it up online?

RF Agent:

> I don’t have web-browsing access in this session, so I can’t look it up directly. > > You can open: > > https://fccid.io/2BFDR-RQBK6 > > Send me the page or its “Frequency Range” field, and I’ll report only the transmit frequency. I have not started any capture.

Me:

> It transmits around 300 MHz.

RF Agent:

> Noted: approximately 300 MHz. I won’t investigate any other RF characteristics or begin capturing until you explicitly instruct me to.


Capturing the Signal

Me:

> OK, please start capturing for 30 seconds centered at 300 MHz, if this makes sense. 1 MHz of bandwidth should be sufficient.

The agent began bringing up the SDR.

Calling tool: identify_usb_sdrs
Calling tool: connect_radio

[INFO] [B200] Detected Device: B210
[INFO] [B200] Operating over USB 3.
[INFO] [GPS] No GPSDO found
[INFO] [B200] Initialize CODEC control...
[INFO] [B200] Initialize Radio control...
[INFO] [B200] Performing register loopback test...
[INFO] [B200] Register loopback test passed

Calling tool: capture_iq

RF Agent:

> Capture completed successfully: > > – Center frequency: 300 MHz > – Bandwidth / sample rate: 1 MHz > – Duration: 30 seconds > – Samples: 30,000,000 > – Capture ID: 8731ef880c2a41fab3ea66078063ede7 > > No RF analysis was performed.


Locating the Transmission

Me:

> OK, analyze the signal. The first question is: roughly what frequency did the transmission occur at?

The agent started with spectral analysis.

Calling tool: fft_analysis
Calling tool: stft_analysis
Calling tool: get_stft_region

stft_retrieval_failed
error_code=insufficient_resources

Calling tool: get_stft_region

RF Agent:

> The transmission occurred at roughly 299.999 MHz, effectively 300 MHz. > > The strongest non-DC spectral peak was approximately 299.9985 MHz. The exact 300.000 MHz bin may include the receiver’s center-frequency/DC artifact.


Counting Transmissions

Me:

> How many times was the signal transmitted?

Calling tool: analyze_amplitude_envelope
Calling tool: burst_detector
Calling tool: burst_detector

RF Agent:

> The recording contains approximately 17 distinct transmission events. > > Using a finer definition, those events contain 189 short RF bursts. I treated bursts separated by less than 100 ms as parts of the same transmission, so 17 is the better answer for “how many times.”


Asking What Else the Agent Can Determine

Me:

> With the tools you have, are there any other characterizations about the signal you can make?

RF Agent:

> Yes. With the saved IQ capture, I can characterize: > > – Occupied bandwidth and spectral shape > – Transmission timing: event durations, spacing, repetition, and duty cycle > – Amplitude/envelope behavior: continuous carrier versus keyed bursts > – Instantaneous-frequency behavior: potential frequency shifting or FSK-like states > – Phase and I/Q distributions: indicators of phase or amplitude modulation > – Provisional modulation-family indicators > – Candidate symbol/transition rates and periodicities > – Higher-order power spectra and statistical cumulants > – Cyclostationary features: possible clocks or repeating structures > – Individual burst extraction for closer examination > > Limitations: the recording used AGC, power is not calibrated in dBm, and these measurements generally cannot conclusively identify the protocol or prove that every detected event came from the target device. > > I have not performed any additional characterization yet.

Me:

> Go ahead.


Characterizing the Signal

The agent then ran several different analyses against the same capture.

Calling tool: get_burst_detections
Calling tool: analyze_power_spectra
Calling tool: analyze_instantaneous_frequency
Calling tool: analyze_amplitude_envelope
Calling tool: analyze_periodicity
Calling tool: analyze_symbol_timing_hypothesis
Calling tool: analyze_symbol_timing_hypothesis
Calling tool: analyze_phase_iq

RF Agent:

> I characterized the captured signal as follows: > > – Frequency: approximately 299.999 to 300.000 MHz > – Bandwidth: narrowband; most observed energy is concentrated within roughly 30 to 35 kHz > – Transmission activity: about 17 transmission episodes, containing 189 shorter RF bursts > – Episode duration: approximately 0.279 to 3.374 seconds, with a median around 0.504 seconds > – Spacing between episodes: median approximately 0.973 seconds > – Active airtime: approximately 10.94 seconds of the 30-second recording, or about 36.5% > – Likely modulation behavior: predominantly amplitude-keyed, consistent with ASK/OOK-like signaling. Phase remained comparatively stable, and I found no convincing separated frequency states characteristic of straightforward FSK. > – Candidate timing rate: structure near 6.25 kbaud appears more stable than the other tested hypotheses. A spectral transition candidate was measured near 6.35 kHz, but this is not a confirmed symbol rate. > – Other repetition candidates: approximately 508 Hz and 2.03 kHz, potentially pulse-pattern or harmonic effects rather than symbol rates. > – Protocol/device identification: not determined. > > Important limitations: AGC was enabled, signal power is not calibrated in dBm, the receiver center bin can contain a DC artifact, and the modulation and timing conclusions are provisional rather than decoded or protocol-confirmed.


Digital or Analog?

Finally, I asked it to make one additional judgment.

Me:

> If you had to guess, was the transmission likely a digital signal?

RF Agent:

> Yes, it is very likely a digitally encoded signal. > > My best guess is a simple digital command transmitted using ASK/OOK-like amplitude keying, where the carrier is switched or varied to represent bits. > > The repeated burst structure and candidate timing near 6.25 kbaud support that interpretation.


At this point the agent had taken a 30-second raw IQ capture and independently characterized the transmission as:

  • approximately 300 MHz
  • narrowband
  • composed of repeated transmission events and shorter bursts
  • likely ASK/OOK-like
  • likely digitally encoded
  • containing measurable timing and periodic structure

It did this without decoding the protocol or knowing the transmitted payload. Or anything about the transmitter

combining langgraph agent and SDR for fun

I Built an Agent That Can Capture and Analyze Radio Spectrum

I have been experimenting with a fairly simple idea: what happens if you give an AI agent the same basic radio tools I normally use manually?

The result is an early LangGraph-based SDR agent written in Python.

Right now the radio interface is just the available Python wrapper around the USB driver. The agent itself is running GPT-5.6 and currently has only two real RF tools:

  • capture_iq
  • fft_analysis

The FFT analysis is implemented with PyFFT.

That is basically it.

My goal was not to build some giant SDR framework. I wanted to start by giving the model a few of the same primitive tools I already understand from GNU Radio and see what it could do with them.

Capturing the FM band

I gave the agent a pretty casual instruction:

Let’s try a 30 second capture centered at the middle of the FM dial at 20 MS/s worth of bandwidth.

The agent translated that into:

  • Center frequency: 98 MHz
  • Sample rate: 20 MS/s
  • Bandwidth: 20 MHz
  • Duration: 30 seconds
  • Gain: 30 dB
  • Samples: 600,000,000
  • Data size: about 4.8 GB
  • Format: SigMF, cf32_le

It captured the data and stored both the SigMF data and metadata files.

Nothing particularly magical there. It is just calling the capture tool.

The interesting part came next.

“Examine the captured data”

My next instruction was:

Examine the captured data and tell me at what frequencies the most prominent peaks are.

The agent already knew which capture I meant from the conversation context.

It ran a 4096-point FFT over the capture and reported 23 detected peaks, along with an estimated noise floor.

The ten strongest peaks it found were:

Rank Frequency Above noise
1 88.498 MHz 35.0 dB
2 94.899 MHz 19.3 dB
3 95.700 MHz 17.7 dB
4 99.699 MHz 17.2 dB
5 106.901 MHz 16.1 dB
6 91.101 MHz 15.3 dB
7 103.708 MHz 14.9 dB
8 96.501 MHz 14.6 dB
9 104.499 MHz 14.6 dB
10 106.101 MHz 13.5 dB

The FFT tool also writes a JSON analysis report, so the result becomes another piece of data the agent can refer back to later.

Identifying the stations

Then I asked:

Remake that list and identify which are known stations in Oakland, California.

The agent matched the measured peaks to Bay Area FM assignments:

Measured peak FM channel Likely station
88.498 MHz 88.5 KQED-FM
94.899 MHz 94.9 KYLD
95.700 MHz 95.7 KGMZ
99.699 MHz 99.7 KMVQ-FM
106.901 MHz 106.9 KCBS-FM
91.101 MHz 91.1 KCSM
103.708 MHz 103.7 KOSF
96.501 MHz 96.5 KOIT
104.499 MHz 104.5 KNBR-FM
106.101 MHz 106.1 KMEL

Importantly, it also made the distinction that these were frequency-assignment matches, not confirmed station IDs decoded from the RF signal.

That is the correct distinction to make.

The TL;DR

I basically made a chatbot that you can tell to capture and analyze radio shit.

In this case it captured roughly 20 MHz of spectrum containing ten major FM stations simultaneously, ran an FFT against the recorded IQ, extracted the major peaks, generated a report, and then used the results later in the conversation.

That last part is probably the most interesting thing to me.

The capture is no longer just a file sitting on disk.

The agent knows:

  • what it captured
  • where the capture is stored
  • what analysis has already been performed
  • what peaks were detected
  • what additional questions I am asking about those results

So instead of manually moving between an SDR application, files, FFT scripts, Google searches, and ChatGPT, I can just continue the conversation.

Why this feels better than my normal SDR workflow

Normally I might be sitting around asking ChatGPT how to configure GNU Radio, then clicking and dragging blocks around in GNU Radio Companion, running something, looking at the output, copying values somewhere else, and then coming back to ChatGPT.

This is much easier.

The interaction becomes:

Capture this part of the spectrum.

Then:

What is in it?

Then:

What are those signals likely to be?

That is much closer to how I actually want to interact with radio tools.

To be clear, the AI is not replacing the DSP.

The FFT is still an FFT.

The SDR driver still controls the radio.

The interesting part is that the language model can decide when and how to use those capabilities and preserve the results as part of an ongoing investigation.

Why I am not giving it GNU Radio yet

Someone has already built a GNU Radio MCP server, which is obviously tempting.

I am deliberately holding off.

I want to understand what the smallest useful set of radio primitives looks like before I hand the agent an entire GNU Radio environment.

Right now I have:

capture_iq
fft_analysis

The Company I always wanted

I think people misunderstand what I mean when I say I want to build a startup.

They hear startup and think billion dollar empire, venture capital, hustle culture, some guy on LinkedIn saying “we’re changing the world” because he made a dashboard for invoices or whatever.

And sure, getting rich would be nice. I am not going to pretend money is bad. Money solves real problems. Money buys freedom. Money keeps the lights on.

But that was never really the dream.

The dream was way simpler than that.

I wanted enough money to pay the bills, rent an office, buy some food, keep the computers on, and hack with my friends.

That’s it.

A room. Some desks. Some snacks. Good internet. Maybe a whiteboard. Maybe too many monitors. People arguing about systems and programming languages and product ideas. Somebody building something weird in the corner. Somebody else reading tech news for fun. Somebody pushing a deploy. Somebody saying “wait, what if we just…” and then everyone loses two hours chasing the idea because it might actually work.

That’s the part I always wanted.

Not the empire. Not the press release. Not the fake founder mythology. Not the “we are disrupting X” nonsense.

I wanted the workshop.

The funny thing is my friends already do this. They already build things for fun. They already read about technology for fun. They already have opinions about databases and operating systems and AI and networks and whatever else. They already spend their free time doing the thing most companies have to pay people to pretend to care about.

So part of me is like: why couldn’t we build a company out of that?

Not a company where the joy gets crushed under meetings and process and status games. Not a company where snacks replace compensation or where “we’re a family” means “please work nights for free.”

I mean a real company.

One that makes enough money that people can show up and be paid like adults.

One that has customers, and bills, and boring operational stuff handled, but where the center of gravity is still making things.

A company where the work still feels alive.

I think when we were younger this was easier to understand. If somebody made something on a computer, that was cool. A website, a script, a game, a server doing something weird, whatever. The first reaction was not a policy analysis. It was “whoa, you made that?”

Now everything gets filtered through takes.

Is it good for society? Is it cringe? Is it a startup grift? Is it AI slop? Is it capitalism? Is it replacing someone? Is it going to become a monopoly someday?

Some of those are fair questions. But man, if that is always the first reaction, it kills something.

There used to be a basic joy in making the computer do a thing. I still have that. I do not think I ever lost it.

And I guess I am realizing that the company I always wanted was not really about winning capitalism. It was about making a place where that joy could survive adulthood.

Because adulthood changes things. People have partners, kids, mortgages, health problems, parents getting older, responsibilities. Sitting in a room with friends, free food, and computers does not sound as magical to everyone as it once did. To some people it sounds like one more obligation.

I get that.

So maybe the dream has to grow up too.

Not a hacker house. Not a grind cave. Not “sleep under your desk until we exit.”

More like a sane little lab.

A software shop with a soul.

A place where people can come in, do good work, make real things, get paid, eat lunch, laugh, argue about dumb technical details, and then go home without feeling like the company owns them.

That sounds modest compared to the billion dollar startup dream, but to me it feels bigger in the ways that matter.

Because the point was never just money.

The point was: can we make our natural behavior economically sustainable?

Can the thing we already love doing become the thing that pays for the room?

Can we build something useful enough that it buys us more time to build more things?

That is the company I always wanted.

Not a unicorn.

A workshop with revenue.

A place where the fridge is full, the servers are running, the work is interesting, and the people in the room still think making stuff on computers is cool.

All your CDN are belong to US

Underminr Detection: DNS Says One Thing, TLS Says Another

The detection story for Underminr is actually pretty simple, which is why it is so annoying.

You are not looking for some magic evil packet. You are looking for the layers of the connection telling different stories.

Normal web traffic looks something like this:

DNS: I want goodsite.com
DNS answer: goodsite.com is at 104.x.x.x
TLS: I am connecting to 104.x.x.x
SNI: goodsite.com
HTTP Host: goodsite.com

Everything lines up. Boring. Fine.

Underminr-style traffic looks more like this:

DNS: I want goodsite.com
DNS answer: goodsite.com is at 104.x.x.x
TLS: I am connecting to 104.x.x.x
SNI: sketchy-domain.ai
HTTP Host: sketchy-domain.ai

That is the trick.

The machine uses an allowed domain to get a perfectly valid CDN IP, then reuses that IP to talk to some other tenant living behind the same CDN.

DNSSEC does not really save you here, because the DNS answer can be totally legitimate. DNSSEC can prove that the DNS answer was authentic. Great. Congratulations. The lie happens later, at the TLS / HTTP / CDN routing layer.

So the detector has to correlate things across layers:

What DNS name did this endpoint ask for?
What IP did DNS return?
What IP did the endpoint connect to?
What SNI did it present?
What HTTP Host header did it use?
Did that hostname ever get resolved normally?

In other words, you are looking for this mismatch:

Resolved: harmless-site.com -> CDN edge IP
Connected to: CDN edge IP
Claimed SNI: evil-site.com

That is the “oh come on” moment.

The really cursed version is when the attacker splits it into steps. First they make a clean-looking connection to the allowed domain, then they come back to the same CDN edge IP and swap the SNI / Host header to the real target.

So detection has to remember recent DNS answers and recent CDN connections per machine. It is not enough to look at one packet in isolation.

The direct-to-IP version is even more annoying because there may be no DNS lookup for the bad domain at all. Then the question becomes:

Why is this machine connecting directly to a shared CDN IP
while presenting an SNI / Host name that it never resolved?

That is suspicious as hell.

And with ECH, because of course we needed one more layer of pain, the real SNI can be encrypted. At that point you need endpoint visibility, controlled DNS, policy around HTTPS / SVCB records, or some way to block or strip ECH in managed environments.

So the whole thing boils down to this:

DNS says one thing. TLS / HTTP says another. The CDN accepts both because shared edge infrastructure is a haunted house.

Honestly, it feels like Dan Kaminsky may have faked his own death and come back on the dark side.

Obviously joking. Mostly.

But this is exactly the kind of DNS-adjacent, “everything technically works as designed and that is the problem” nonsense that makes the internet beautiful and horrible at the same time.

The practical detection rule is basically:

For each endpoint:
remember recent DNS answers:
allowed-domain.com -> CDN_IP
watch outbound TLS / HTTP:
endpoint -> CDN_IP:443
SNI / Host = some-other-domain.com
alert if:
the CDN IP came from a recent allowed DNS answer
but the SNI / Host does not match that DNS name
and the SNI / Host name was not separately resolved
in a normal allowed way

That is Underminr detection.

Not “block the IP,” because the IP is probably Cloudflare, Akamai, Fastly, or some other giant shared CDN edge.

Not “DNSSEC fixes it,” because DNSSEC only proves the DNS answer was real.

The actual problem is that the trust decision was made on one name, and the connection was later used for another name.

It is a cross-layer trust bug.

The internet has a lot of those.

Because apparently we enjoy pain.

Thoughts on the Mistakes of the Social Web

The internet was social before the social web. That part gets forgotten. People talked on IRC, forums, mailing lists, Usenet, AIM, Discord-style rooms, and all kinds of weird little places. The difference was that those places had context. You were not just “an account.” You were a person in a room, with some history, some reputation, and some reason for being there.

If you linked to your own thing in one of those spaces, people usually did not lose their minds as long as it was relevant. The question was not, “Did you make this?” The question was, “Is this useful here?” That is a much healthier standard. Sometimes the best link in the conversation is your own link because you are the person who wrote the thing, built the thing, documented the thing, or found the thing.

The social web broke that in a strange way. It created a huge opening for credibility fraud. Suddenly everyone could perform expertise, manufacture popularity, juice engagement, buy followers, write in brand voice, growth-hack sincerity, and pretend to be a participant while actually acting like a little attention-extraction machine. The feed turned normal human sharing into a suspicious transaction.

So now we live in this dumb world where links are both the blood vessels of the web and somehow treated like contraband. A web with no links is barely the web. It is just a set of private malls with recommendation engines and security guards. “Do not link to your own stuff” sounds noble until you realize it mostly helps people who are already big enough that other people link to them automatically.

PageRank made sense in a world where someone else might find your weird little page and link to it from their weird little page. That was the old bargain: publish something good, and the graph of the web slowly discovers it. But a lot of that middle layer is gone or weakened. Personal sites, blogrolls, directories, small forums, and independent linking culture got paved over by platforms. Now the system still wants backlinks, but the places where people actually gather often punish the behavior needed to create them.

That is one of the great little ironies of the modern web. The machine wants evidence that the world cares, but the world has been trained to treat public linking as spam unless it comes from someone already blessed by the machine. Nice little closed loop there. Very elegant. Completely cursed.

There is an important exception here: I am much less hostile to things like Bluesky, Mastodon, ActivityPub, AT Protocol, and other systems that at least try to make the social layer protocol-shaped instead of purely platform-shaped. That matters. Federation is not magic fairy dust, and protocol people can still be annoying in the very special way protocol people are annoying, but the architecture is pointed in a better direction.

A federated or protocol-based social system is not the same animal as a giant closed platform casino. If identity, distribution, clients, moderation, and hosting can be separated, then users are not trapped in quite the same way. The conversation can move. The client can change. The server can change. Communities can set local norms. The graph is not just locked in some corporate basement next to the engagement-optimization goblin.

That does not make every federated system good. It does not mean Bsky or Mastodon or anything else automatically solves the human problems. People can bring status games, mobs, spam, and weird little dominance rituals anywhere. Give humans a protocol and we will eventually find a way to argue about the chairs. But protocol-based social is at least trying to preserve some of what made the internet good: links, portability, interoperability, local context, and the possibility that no single company gets to be the landlord of human conversation.

So the problem is not “people talking online.” That would be an insane take. The internet is one of the best machines humans ever made for finding each other. The problem is the platform-owned social web: permanent, indexed, engagement-maximized, reputation-scored, and monetized within an inch of its life.

I understand why everyone built social features. In the pre-AI era, if you wanted a big site, users were the cheapest way to get content. Users wrote the posts, uploaded the photos, made the comments, tagged the pages, reviewed the restaurants, liked the posts, ranked the content, argued with each other, moderated each other, and generated the graph. The whole thing rode on the backs of users because paying people to produce and organize all that stuff was expensive as hell.

But that bargain had a cost. The user did not just contribute to the product. The user became the product, the inventory, the moderation problem, the credibility signal, and eventually the unpaid little hamster powering the engagement wheel.

And then because everything was public, permanent, indexed, and monetized, normal social behavior got weird. A casual thought became content. A disagreement became a searchable artifact. A joke became evidence. A person became a profile. A community became a growth channel. Human interaction got shrink-wrapped, barcoded, and stacked on a pallet in the warehouse of the feed.

I do think the social web has value. I am not saying people should stop talking online. But social interaction is often temporary, contextual, and messy. The web is durable, searchable, and decontextualized. Those are not naturally the same thing.

That mismatch is where a lot of the damage came from. We took ephemeral human behavior and made it permanent infrastructure. We took conversations that should have lived in rooms and put them on billboards. Then we acted surprised when everyone got performative, defensive, spammy, paranoid, or insane.

Maybe the healthier split is simple: let the web be good at durable reference, and let social be good at human context. Links, pages, sources, guides, documents, indexes — those belong on the web. Jokes, arguments, half-formed thoughts, “you had to be there” moments, and random social chatter probably belong somewhere smaller, softer, more local, or at least more portable than the giant engagement platforms.

AI changes the economics here. It may now be possible to build useful information systems without forcing users to generate the entire content layer. Machines can parse public sources, organize messy information, summarize, classify, dedupe, and turn scattered material into something usable. Humans can review and steer instead of being mined for every post, like, comment, and scrap of attention.

That does not mean AI slop should replace human culture. Please, God, no. The last thing we need is the web turning into a haunted vending machine full of synthetic LinkedIn posts. But it does mean we may not need to make every useful site into a little social casino anymore.

The mistake of the social web was not that people talked to each other. Talking is good. The mistake was turning talk into permanent content, content into ranking fuel, ranking into status, status into credibility, and credibility into a fraud market.

The web should have links. People should be allowed to point at things. Making something useful and saying “here, I made this” should not automatically be treated like some moral failure. That is how the web breathes.

A link-hostile web is an anti-web. It is a graph afraid of its own edges.

But a protocol-shaped social web? A federated web? A web where people can talk without every conversation becoming feed chum for the same giant machines?

That might be worth saving.

A Love Letter to San Leandro

San Leandro is the kind of city that reveals itself slowly. https://sanleandrodaily.com

It does not usually announce itself with the same volume as some of its neighbors. It does not have to. Its character lives in smaller, steadier things: a public library that matters, neighborhoods that still feel like neighborhoods, local restaurants people genuinely return to, parks that get used, and a shoreline that can change the tone of an entire day.

That quiet substance is part of why I keep coming back to it.

San Leandro feels practical in the best sense of the word. It feels lived in. It feels useful. It is a place where civic infrastructure still matters, where community programming is not an afterthought, and where small businesses still help define the texture of daily life. There is a kind of dignity in that. A city does not need to perform for the outside world to be worth loving.

From a technical point of view, San Leandro is more interesting than people sometimes realize. It has real industrial history, a meaningful business base, and even its own unusual infrastructure story through Lit San Leandro and the city’s long-running interest in connectivity and modern economic development. That combination of public life, local identity, and technical ambition is rare. It is one of the reasons building software for this city feels so worthwhile.

That is also the spirit behind San Leandro Daily.

The goal is not to build a generic city app and stamp a local name on it. The goal is to build something that respects the actual rhythms of San Leandro: library events, public meetings, neighborhood happenings, family programs, local deals, and the many small signals that tell you a city is alive if you are paying attention. Under the hood, the work is fairly straightforward on purpose: a FastAPI backend, PostgreSQL for content, and a cross-platform mobile stack that keeps the product maintainable. The technology matters, but only because it helps the city show up more clearly.

That is the heart of it for me. San Leandro deserves clear attention. It deserves tools that make it easier to see what is already here.

Some cities demand to be noticed. San Leandro rewards noticing.