How I message anyone on their app of choice, from one command

I work with people who message me via different apps — one only checks Signal, family’s on iMessage, a couple more are Telegram or WhatsApp. Sending a quick reply used to mean hunting down the right app, finding the person, and typing it out. Small friction, but it lands all day long. So this week I built one command that sends to any of those apps, and I wrote two safety habits straight into it. Here’s what it does, and how to build a version for yourself.

💡 Two rules make an assistant safe to trust with your messages: it shows you the message before it sends, and it never hides that an assistant sent it.

The reply I sent without opening an app

The moment it earned its place: a client I work with prefers Signal. I had a reply ready, so I typed one line at my keyboard naming the app, the person, and the message. Instead of sending, the tool printed exactly what would go out — the full text, with a small note on the end saying it came through my assistant on my behalf. I read it, confirmed, and it sent. I never opened Signal, never scrolled to find the contact, and the person on the other end could see at a glance that an assistant had sent it for me.

That’s the whole tool: one line to reach anyone on whatever app they use, with a preview I have to approve and an honesty note that adds itself every time.

What “one command for every app” actually means

The tool is a wrapper: a small script that sits in front of several other tools and gives them one simple front door. On its own, each messaging app has its own fiddly way to send a message from a keyboard, and the wrapper hides all of that. I tell it three things (which app, who to, and what to say) and it works out the rest: it picks the right method for that app, adds my honesty note, and either previews or sends.

You don’t need to know how each app works underneath. That’s the point of a wrapper: learn one simple command instead of four awkward ones.

Two habits worth stealing, even if you never build the tool

The tool is handy. The two ideas inside it are the real takeaway, and they apply far beyond messaging.

Make the safe choice the default. By design, the command previews and sends nothing. It only sends when I add a short confirm flag. So a slip of the finger, or an assistant getting ahead of itself, can’t fire a message at a client by accident — the worst case is a preview I ignore. Whenever you automate something with real-world consequences, set it up so the harmless outcome is what happens if you do nothing.

Disclose by construction. The “sent by my assistant” note isn’t something I remember to add — the tool appends it to every message automatically, and won’t double it up if it’s already there. That means the honesty can’t lapse on a busy day, because it doesn’t depend on me. If there’s a disclosure or a disclaimer you believe in, build it so it happens on its own rather than trusting yourself to remember it each time.

Build your own, from no-code up

Start at whatever level suits you. Each step reaches further than the last.

1. The no-code version: prefilled links. Most apps open to a ready-to-send message from a plain web link, and you just tap send. WhatsApp uses https://wa.me/[number]?text=[your message]; your phone’s Messages app opens from sms:[number]&body=[your message]. Paste one of these together by hand and you’ve got today’s easiest “send from anywhere,” with nothing installed.
2. The one-command version: a small wrapper. Ask your AI assistant to write a short script that takes the app name, the recipient, and the message, and sends it — appending your honesty note every time. You don’t have to write it yourself; the first prompt below does it. Keep it to one or two apps to begin with.
3. Give it a real send, with the preview gate on — this is the step to get right. Sending for real is where each app differs, and where care matters most. Wire up one app end to end, and make preview the default: the tool shows you the message and sends only when you add a confirm flag. Be honest about the limits — some apps let a script truly send on its own (Signal has a proper command-line tool for this), while others, like WhatsApp, only let you pre-fill the message so you still tap send yourself. Build the preview-first behaviour before you build anything else; it’s the safety net that makes the rest safe to use.
4. Reuse a login you already have. If you already use a tool that reads one of your accounts — say a script that reads your Telegram — you can often reuse its login to send too, instead of setting up a second one. I pointed my sender at the Telegram session I’d already authorised, so there was nothing new to log into.

Sample prompts

Paste these into your AI assistant and fill in the brackets.

Build the wrapper, safe by default:

Write me a small command-line script that sends a message to a person on a
chosen app. It should take three inputs: the app name, the recipient, and the
message. Two rules: (1) it must PREVIEW by default — print exactly what would be
sent and send nothing — and only actually send when I pass a --yes flag; (2) it
must always append this line to the end of every message: "[your honesty note,
e.g. 'Sent via my assistant']", and must not add it twice if it's already there.
Start with just [WhatsApp prefill] and explain how to run it.

Add one real send channel:

Add [the app] to my message script as a real send (not just a prefilled link).
Tell me what I need to install or authorise first, keep the preview-by-default
and the --yes confirm rule, and make sure the honesty note is still appended.
If this app can't truly auto-send, tell me plainly and fall back to opening the
chat with the message pre-filled.

Reuse an existing login instead of setting up a new one:

I already use [a tool that reads my Telegram/Signal/etc.] and it's logged in.
Can my new send script reuse that same login so I don't have to authorise a
second time? If so, show me how to point it at the existing session safely,
without copying any secret into a place it could be logged.

Where this goes wrong, and where to hold the line

The failure mode to guard against is an assistant sending an outward message — to a client, to anyone who matters — without you seeing it first. That’s exactly why the preview gate exists, and why I keep it on hardest for client messages: those get drafted, previewed, and sent only on my explicit okay, never on the assistant’s own initiative. Automation should shorten the distance to sending, not remove you from the decision.

Two smaller cautions. Handle people’s phone numbers and handles as the private data they are — don’t let them leak into logs or shared files. And remember each app needs its own setup or login before it can send; the wrapper makes sending simple, but it can’t skip the one-time permission each service asks for.