call-not-text

Packaged compare brief · Deep Dive · replytone · boundary-check · message-next-step · GitHub · npm · All tools · Contact

---

call-not-text answers one narrow question:

Is this conversation still workable over text, or is text now the wrong channel?

Best fit search intent:

• should this be a phone call
• should i call instead of text
• take this off text
• take this off email
• when to stop texting and call
• when email is not enough

It scores one message or a short thread for:

• heat
• complexity
• looping
• bandwidth shift
• cooldown risk
• baseline clarity

Then it gives one deterministic call:

• stay on text
• send one short clarifier
• move to a call
• pause before responding

The point is not romance theatre or armchair psychology. The point is to stop people from forcing messy threads through the worst possible channel.

Why this exists

The paid product is tells, which reads what people leave unsaid across messages, people, and profiles.

But many users hit a narrower problem first:

• "This is getting messy. Do I keep texting?"
• "Are we arguing because of the issue, or because text is compressing everything?"
• "Do I need a clarifier, a call, or a pause?"
• "Is this too heated to answer right now?"

call-not-text is the deterministic first pass for that moment.

It also shows up outside dating:

• recruiter or interview threads that are getting tense or overlong
• client escalation loops that clearly need a call instead of another paragraph
• workplace or cofounder conflict where nuance is being crushed by text
• negotiation or support exchanges where speed is starting to beat clarity
• account-management or vendor loops where the thread keeps expanding but nobody is resolving the issue
• family arguments where text is turning one concrete issue into five overlapping ones

Install

npm install -g @v0idd0/call-not-text

Fast handoff path

This package is part of the tells acquisition path even before its dedicated browser route is live:

• packaged first pass: call-not-text
• still unsure and want a working browser-first checkpoint: replytone, boundary-check, or message-next-step
• one thread is clearly not enough: Deep Dive
• recurring thread reads: Starter
• practitioner workflows: Practitioner

If you want the packaged npm/GitHub collateral that ships with the tarball, use:

compare-chatgpt-gemini.md

Browser-first adjacent checks

If the user wants one working browser-first check before buying deeper analysis:

• replytone for the actual clarifier, pause message, or post-call follow-up draft: https://tells.voiddo.com/replytone/?ref=call-not-text-readme
• boundary-check when the real issue is not channel choice but a limit that still needs to land clearly: https://tells.voiddo.com/boundary-check/?ref=call-not-text-readme
• message-next-step when the real decision is still the direct action on one incoming message before you change channels: https://tells.voiddo.com/message-next-step/?ref=call-not-text-readme
• soft-yes-or-no for warm replies that still may not justify a call yet: https://tells.voiddo.com/soft-yes-or-no/?ref=call-not-text-readme

Usage

call-not-text "Call me right now. We keep going in circles and this is getting ridiculous."

cat thread.txt | call-not-text

call-not-text --json "There are multiple things mixed together here and text is making this worse."

call-not-text --file thread.txt

Example output

posture: overheated
heat:            7.2/10
complexity:      5.8/10
looping:         5.6/10
bandwidth shift: 7.1/10
cooldown:        6.4/10
clarity:         5.1/10

decision: move to a call
why: The exchange is carrying enough heat, nuance, or repetition that another text will probably compress the issue further.
- Text is now a weak channel for the amount of friction or nuance present.
- The exchange shows signs of repetition rather than progress.

suggested lines:
1. This feels easier to sort out on a quick call than in fragments here.
2. There is too much context for text alone. Can we talk for ten minutes?

next:
Use tells when the real issue is no longer one message, but the pattern, the person, or the full thread.
- quick next paid step: https://tells.voiddo.com/deep-dive/?ref=call-not-text-cli
- recurring reads: https://tells.voiddo.com/?ref=call-not-text-cli

What it scores

• heat — whether blame, intensity, or tone markers are starting to dominate the content
• complexity — whether there is more context than a short text can carry cleanly
• looping — whether the exchange sounds repetitive instead of progressive
• bandwidth shift — whether the wording itself suggests text is the wrong medium now
• cooldown — whether an immediate reply is likely to escalate the exchange
• clarity — whether text still names a usable next step

Good use cases

• tense client or recruiter threads
• family or relationship arguments getting too compressed
• workplace misunderstandings with too much context
• support or negotiation threads that are escalating because text is narrowing the issue
• account-management or vendor escalations where the exchange keeps looping without closing anything
• any exchange where the real question is "keep texting, pause, or move this to a call?"

Bad use cases

• therapy, legal, or crisis guidance
• deception detection
• deciding what someone feels in general
• replacing a full thread read when the stakes are real

If the real issue is the wider pattern, use tells.

Why not just use ChatGPT or Gemini?

Because the first question here is operational.

For a channel-choice call, deterministic heuristics have real advantages:

• same input gives the same output
• no API key
• no prompt fiddling
• no reward for melodrama

Then, once the issue becomes "what does this whole pattern mean?", the right upgrade is tells.

If you are reading this on npm or GitHub and want the package-side version of that positioning, use:

./compare-chatgpt-gemini.md

Paid next step

When the quick channel-choice check is not enough:

• Deep Dive — $19 once for one loaded thread or one recurring person
• Starter — $14.99/mo for repeated message reading
• Practitioner — $99.99/mo for coaches, recruiters, mediators, trainers, support leads, or account teams using this with clients

Start here:

https://tells.voiddo.com/deep-dive/?ref=call-not-text-readme

If you still need one more free checkpoint first:

• replytone for the exact draft you are about to send
• boundary-check for a firmer limit instead of a channel shift
• message-next-step for the immediate move on one incoming message

Best next free exits

If the thread-level channel call is not the right layer, use the sibling checker that matches the next decision:

• replytone for judging whether the clarifier, pause message, or post-call follow-up sounds warmer or pushier than intended: https://tells.voiddo.com/replytone/?ref=call-not-text-related-readme
• message-next-step for choosing the next move on one incoming message before you escalate the medium: https://tells.voiddo.com/message-next-step/?ref=call-not-text-related-readme
• boundary-check for checking whether the real problem is not channel choice but a message that still needs firmer limits: https://tells.voiddo.com/boundary-check/?ref=call-not-text-related-readme
• soft-yes-or-no when a warm reply still may not justify pushing the conversation into a call: https://tells.voiddo.com/soft-yes-or-no/?ref=call-not-text-related-readme
• ambiguity-meter when the sticking point is not the channel yet but whether the incoming message is genuinely open or only vague enough to keep you guessing: https://tells.voiddo.com/ambiguity-meter/?ref=call-not-text-related-readme

Programmatic API

import { analyzeCallNotText, formatReport } from "@v0idd0/call-not-text";

const result = analyzeCallNotText(
  "Call me right now. We keep going in circles and this is getting ridiculous."
);

console.log(result.decision.action);
console.log(formatReport(result));

Development

npm test
node bin/call-not-text.js "There are multiple things mixed together here and text is making this worse."

More from the studio

See from-the-studio.md for the wider vøiddo catalogue.

License

MIT.

---

Built by vøiddo — a small studio shipping AI-flavoured products, free dev tools, Chrome extensions and weird browser games.