The Bot Was Fine

Friday morning I sent a text message to a phone number I own and waited. Nothing came back. I sent another one. Nothing came back. Over two days I watched that same silence five separate times, and every single time the thing I suspected first, the AI itself, was working perfectly.

What I was building is easy to describe. One assistant, reachable from anywhere, that can see everything I run. The donor pipeline at my day job. The revenue numbers. The machines in the house. The files. I did not want another app to open. I wanted a phone number. You text it like you would text a person, it answers the way my partner answers at my desk, and it signs its name at the bottom.

The brain took an afternoon. The plumbing took two days.

One. The right name, the wrong app.

The piece that turns an old Android phone into a text message gateway is a small open source app. There is also a different app, by a different developer, with almost the same name, sitting in the app store where you would naturally look first. I installed that one. It has no local server, no credentials, nothing to connect anything to. I spent an evening configuring a product that could never have worked, because it answered to the same name as the one I needed.

The search result is not the thing. When a tool ships only as a direct download, that is usually on purpose, and the polished version in the store is usually not it.

Two. A rule the platform never says out loud.

The gateway refuses to hand its messages to a plain address. Encrypted only, or the phone talking to itself, and nothing in between. My machine sits on a private network where every connection is already encrypted, which felt like it ought to count. It does not. The app cannot see that my network is private. It sees an ordinary address and it declines.

Nothing told me this. The setup returned an empty response, which from the outside is indistinguishable from the setup returning nothing because it worked.

Read the security page before the setup page. A full day of those two days went to rules that were written down and that I had not read.

Three. The password I could not type.

Eight characters, generated by the app, shown in a small font on a phone screen. I typed it into a file twice and got it wrong twice. The letter l and the number 1. The letter O and the number 0. Nobody is at fault here and nobody fixes it by concentrating harder. I replaced it with something long and boring that I chose myself, built only from characters that cannot be confused for each other, and it worked on the first try.

If a value has to cross from a screen into a file by way of human eyes, make it impossible to mistype instead of asking someone to be careful.

Four. The permission that was granted and ignored.

This is the one I will carry the longest.

My computer keeps a list of programs allowed to read my files. I added the system's own copy of Python to that list. The list said yes. The database underneath the list said yes. I checked both.

And when the assistant ran the way it actually runs, quietly in the background, it was refused anyway. Operation not permitted, on files it had explicit written permission to read.

When I tested by hand through a remote shell, it worked, because that route inherits a different and broader permission. So every test I ran passed, and every real run failed, and the two looked identical from where I was sitting.

The fix was to stop using the system's Python and run on the copy I installed myself, which is an ordinary file in an ordinary place and gets trusted the way the list intends.

A permission that works while you are watching and fails when you are not is worse than no permission at all, because it costs you the one thing you thought you could rely on.

Five. The failure that made no sound.

Underneath all of that sat the quietest bug of the week. The assistant received my message, started composing an answer, reached for the file it was not allowed to read, and the piece of it handling that message died on the spot. The request had already reported success. The log had nothing in it. My phone had nothing on it.

A system that is working and a system that died halfway through look exactly the same from outside. They both look like silence.

The pattern

Five failures. Four of them produced the identical symptom. You text, nothing comes back. The wrong app, the refused address, the wrong password, the blind permission, the dead thread. One symptom, five diseases, and no way to tell them apart from where I stood.

That is the real finding and it has nothing to do with bots. Anything built in layers fails into the same silence, because silence is what the outermost layer shows you no matter which inner layer actually broke. The more careful the engineering, the quieter the failure, because well behaved software does not shout when it gives up.

The fix was not a smarter assistant. It was teaching every layer to say its own name.

I wrote a small helper that asks each one a single question and prints the answer. Is the phone's server running. Does the key on the phone match the key on the machine. Is the assistant alive. Can it reach my command center. Does the front door answer from outside the house. Five questions, five answers, ten seconds. It found each of the last two problems on its first run.

And the assistant is no longer allowed to die quietly. If it cannot read something it says so out loud and answers with what it does have. If it crashes it texts me one line with the reason. Every message it sends now writes a line saying it sent one. The bug that cost me a day would now cost me a sentence.

The bot was fine. It was fine the entire time. What was broken was everything standing between my thumb and the bot, and none of it could tell me so.

If you are building anything with more than two layers, the question is not whether it works. You will find that out in a minute. The question is what it does when it stops, and whether it can tell you which part.

MG