You just finished writing a long, structured update to a client in Gmail. You hit send, switch to Slack, and freeze for a second. Your fingers want to keep typing in that same formal tone. Wrong app. Wrong vibe.
So you delete the "I hope this message finds you well" you almost typed, and start over with a friendlier hello. Three apps later, you're rewriting again for a Notion doc. Then again for a code review comment. Every time, you do the same small piece of mental work: figuring out the tone the app expects.
The average digital worker switches between apps about 1,200 times a day, and each switch comes with its own writing conventions. Your brain knows them, but it pays a tax every time it has to re-tune. Smart writing rules are the fix. They let your tools auto-adjust the tone for each app, so you don't have to.
Why one writing tone doesn't fit every app
Each app you use is built for a different kind of communication. The conventions baked into them tell you what kind of writing belongs there, often without you even noticing.
Slack is built for speed. Messages are short, threaded, and often skim-read. A formal "Dear team," reads as stiff or vaguely passive-aggressive. Slack's own research on workplace communication found that 70% of workers prefer informal communication from coworkers over strictly professional language.
Email is the opposite. It's the place for structured thinking, documentation, and messages that may get forwarded or kept on file for years. A casual "yo" works fine in Slack and lands wrong in a client email. The format itself — subject line, greeting, signature — invites a more considered tone.
Then there are docs. Notion, Google Docs, Confluence pages. They sit somewhere in between: more structured than chat, less performative than email. Lists and headings matter. Sentences get longer.
Code editors and CLIs need a different style entirely. Comments and commit messages should be terse, specific, and in the present tense. "Handles the case where the user is null" beats "Hi team, I made a small change to handle a tricky edge case."
X (Twitter) posts are their own world: punchy, line-broken, often deliberately rough around the edges to feel native to the feed. LinkedIn posts skew warm and personal. Project tools like Linear and Jira want plain, decision-first comments without preamble.
You already know all of this. You apply it constantly. The cost is just that you do it manually, every single message.
The hidden cost of manually switching tone
Tone-switching feels free because each individual switch is small. But the totals add up fast.
Asana's Anatomy of Work Index found knowledge workers use about 10 different apps per day and switch between them roughly 25 times. A separate Harvard Business Review study put the figure at nearly 1,200 toggles per day across applications and websites — about one switch every 24 seconds during an eight-hour day.
Most of those switches involve writing. A Slack reply, an email draft, a Linear comment, a doc edit. Each one demands a quick mental re-tune: - How formal does this need to be? - How long? - Should I use emoji here? - Bullets or paragraphs? - Do I sign off, or just stop?
Multiply those micro-decisions across hundreds of messages a day and you've got real cognitive load. 45% of workers say toggling between too many apps makes them less productive, and 43% report it's mentally exhausting. A chunk of that tax goes into figuring out what kind of writing the next app wants.
What "smart writing rules" actually mean
A smart writing rule is two things glued together: a trigger (which app you're in) and a prompt (how the AI should rewrite or polish your text). When you write or speak into the active app, the rule fires and reshapes the output to match.
You don't tell the tool "make this casual" each time. You set the rule once for Slack, once for Gmail, once for Notion. The tool detects which app has focus and applies the matching style.
The result: you type or dictate the same way everywhere, and the polished output adjusts to wherever it's going. The friction of switching tone drops from "every message" to "set it once."
This is different from a generic AI tone changer where you paste text, pick a tone from a dropdown, and copy the result back. That still puts the work on you. Smart rules remove the dropdown.
Anatomy of a good writing rule
A good rule for one app has roughly five components. Skip any of them and the output starts to drift.
1. Formality level
Casual, neutral, professional, or technical. This sets the temperature of the whole message: vocabulary, contractions, sentence rhythm.
2. Length target
Short and direct (Slack), medium and structured (email), or whatever the app calls for. Rules without length guidance tend to over-explain by default.
3. Structure
Bullets, numbered lists, paragraphs, headings. A rule for Notion should encourage structure. A rule for Slack should discourage it.
4. Emoji and punctuation policy
Some apps welcome emoji, some don't. Some communities use em dashes, some don't. Spelling out the policy stops the AI from picking a default that doesn't match your team.
5. Sign-off behavior
Email needs a sign-off. Slack doesn't. Code comments don't. If you don't specify, you'll get inconsistent endings. Half your Slack messages will randomly close with "Thanks," because the model thinks that's polite.
Together, these five settings turn a vague "make it sound right for this app" into a rule that produces consistent output every time.
This is exactly what Voicr's Smart Rules feature does on macOS. You hold the FN key, speak from any app, and the rule for that app polishes your speech automatically. The output is already in the right tone before it hits your clipboard. No dropdowns, no tone pickers, no "wait, let me rewrite that."
Example rules you can steal
Below are rule prompts for the apps you probably use most. They're written in plain language, the way you'd prompt any model. Drop them into Voicr, a Raycast AI command, a Shortcuts action, or any tool that runs your text through an LLM.
Slack rule
``` Rewrite the input as a casual, friendly Slack message. Keep it to 2-3 sentences max. Use contractions. Drop greetings and sign-offs. Don't use bullet points unless I literally list things. Light emoji is fine if it fits naturally. Skip "Hope you're well" and similar filler. ```
Email rule (Gmail, Outlook, Apple Mail)
``` Rewrite the input as a professional but warm email. Start with a brief greeting using the recipient's first name if I mentioned it. Use clear paragraphs of 2-4 sentences each. End with a polite sign-off ("Best," or "Thanks,"). Don't use emoji. Use contractions sparingly to soften the tone while staying professional. ```
Notion / Docs rule
``` Rewrite the input as clear, structured document content. Use short paragraphs and bullet lists where appropriate. Prefer plain headings over inline bold. Strip first-person filler like "I think" or "I want to say". Make it sound like a finished section, not a chat message. ```
Linear / Jira rule (engineering tickets)
``` Rewrite the input as a focused engineering comment on a ticket. Be direct and terse. Use present tense. Lead with the conclusion or decision. Bullet sub-points if there are multiple items. No greetings, no sign-offs. ```
Code editor rule (VS Code, Cursor, Xcode)
``` Rewrite the input as a short code comment. Present tense. No "I" or "we". One sentence ideal, two max. Don't restate what the code obviously does — explain the why or the non-obvious bit. ```
X (Twitter) rule
``` Rewrite the input as a tweet. Punchy, line-broken for readability, no corporate phrasing. Lowercase is fine. Drop hedges like "in my opinion". 240 characters max. No hashtags unless I include them. ```
These are starting points. Tweak the wording until the output sounds like *you*, not the default AI voice.
Mapping rules to the apps you actually use
You don't need a rule for every app you open. You need rules for the apps where you write a lot.
Walk through your last week and notice where most of your typing actually went. For most people it's a short list: 1. One chat app — Slack, Teams, Discord, or iMessage 2. One email client — Gmail, Outlook, Apple Mail 3. One docs or notes app — Notion, Google Docs, Apple Notes, Obsidian 4. One project tool — Linear, Jira, Asana, Height 5. One code editor or terminal — VS Code, Cursor, Xcode, iTerm 6. Maybe one social app — X, LinkedIn, Bluesky
Set up rules for those six (or fewer). Everything else can fall back to a sensible default polish rule. There's no reward for having 30 rules. There's a penalty, because you have to remember which ones apply where.
For a deeper look at the dictation side of each app, see our guides on voice-to-text in Slack, dictating emails on Mac, and voice input in Notion.
Common mistakes when setting up writing rules
Most rule setups go wrong in one of a few predictable ways.
Rules that are too vague
"Make it sound professional" gives the AI too much room. Specify length, structure, sign-off behavior, and emoji policy. The more concrete the rule, the more consistent the output.
Rules that are too rigid
The opposite trap. If your Slack rule enforces a five-word maximum, every message comes out clipped and weird. Set guidelines, not handcuffs.
Identical rules with different names
It's easy to copy your email rule to "Confluence" and "Notion" and "Jira" and call it a day. They each need their own touch. If two rules are truly identical, merge them and let one handle both apps.
Rules that fight your voice
Your writing has personality. A rule that turns everything into corporate boilerplate will make you stop using the tool within a week. The point is to translate your voice into the right register for each app, not to replace it with someone else's.
Forgetting the fallback
What happens when you write in an app with no rule? Most tools fall back to a generic polish. Make sure that fallback is something you actually like, because it will run more often than you expect.
Putting smart writing rules into practice
If you take one thing from this, take this: the cost of tone-switching is real, and it stacks up fast. Every micro-rewrite, every small re-tune, adds up across a workday. Smart writing rules are how you stop paying that tax.
Start small. Pick the two apps where you write the most — usually Slack and email — and write a single rule for each. Use them for a few days. Notice what feels off, and adjust the wording. Then add a third rule for whatever app comes next in your weekly writing volume.
If you'd rather not stitch this together yourself, Voicr does it natively on macOS. Hold FN from any app, speak naturally, and the rule for that app polishes your words on the way to your clipboard. Slack messages come out casual, emails come out professional, code comments come out terse — and you didn't have to think about any of it. That's the goal: writing that fits the room, without rewriting it yourself.