email_automation v1.0.0

name: email_automation description: "Set up personal inbox automation: durable filters and rules, scheduled sends, reusable templates with follow-up sequences, and safe auto-responders. Use when the ask is to make an inbox run itself (Gmail, Outlook, Thunderbird, self-hosted via Sieve). Not for manual triage habits, sender-side deliverability infrastructure, or newsletter broadcast writing."

Email Automation

Purpose

Build a personal inbox that sorts, sends, and replies on its own: filters and rules that keep holding up months later, scheduled sends that land at the right hour, template plus follow-up sequences for recurring conversations, and auto-responders that never embarrass the owner.

Scope boundaries, stated plainly:

• This skill is personal inbox automation. It is about one mailbox receiving less manual work.
• It is not manual triage. The inbox-zero-systems cousin covers how a person works through mail by hand (labels, processing habits, triage sessions). This skill covers what the system does before the person ever sees it.
• It is not deliverability infrastructure. The email-deliverability cousin covers the sender side: SPF, DKIM, DMARC, reputation, bulk sending. This skill never sends to lists or manages sending reputation.
• It is not newsletter writing. The email-newsletter cousin covers broadcast copy, subject lines, and list growth. This skill covers personal correspondence, not one-to-many publishing.

Triggers: "automate my inbox", "set up filters that actually work", "schedule my emails", "build a follow-up sequence", "auto-reply while I am away", "stop me from seeing newsletters in my inbox".

Workflow

1. Inventory before automating

List what actually arrives for two weeks, grouped by type: bills and receipts, newsletters and promos, human threads, calendar noise, shipping notifications, recruiter mail, everything else. Automate the high-volume, low-judgment types first. If a type needs a judgment call every time, it does not belong in a filter.

2. Filters and rules that hold up

Rules that survive share traits: they match stable sender traits (domain, a List-Unsubscribe header, a consistent subject token), they do the smallest action that solves the problem (label and skip inbox beats delete), and they end with a review pass.

Gmail (steps verified 2026-10-06 against Google's help page):

1. Open Gmail on the web, click the search box's "Show search options" icon, enter criteria (From, Has the words, etc.).
2. Click Search first to preview what matches. Do not skip this.
3. Click Create filter, choose the action (Skip the Inbox, Apply the label, Delete it, Never send it to Spam, and others), then click Create filter.
4. Manage or edit later under Settings > See all settings > Filters and Blocked Addresses. Filters can be exported and imported as .xml from the same tab, which is the portable backup for a Gmail filter set.

Outlook desktop rules (steps verified 2026-10-06 against Microsoft Learn): File > Manage Rules & Alerts > New Rule > "Apply rule on messages I receive", pick conditions, pick the action, name it, turn it on. Client-only rules need Outlook running; server rules run without it. Prefer server rules where available.

Thunderbird: use Message Filters (client-side). Rules run when Thunderbird checks mail, so the client must be open or mail waits. Keep provider-specific click paths generic here; confirm before quoting exact menu names.

Self-hosted or anything IMAP with server-side filtering: Sieve is the standard (RFC 5228; vacation extension RFC 5230). The generator below produces a starter script with three parts: VIP senders stay in the inbox, receipts and notifications file away, and a vacation responder answers direct mail only while staying silent for mailing lists. Test the script on a test folder first, then paste it into the server's Sieve editor (Roundcube's Filters tab with the managesieve plugin, or the provider's control panel).

Anti-patterns that break rule sets:

• A delete filter with an empty or overly broad condition. One typo in the From field and a filter eats real mail. Never build a filter that matches "everything except" unless you have reviewed every exception.
• Auto-forwarding mail to an external address without a second thought. Forwarding rules are exfiltration if the account is ever compromised. Flag this as a decision, never a default.
• Stacking filters that fight each other. Specific before general, and a "stop processing" action where the provider supports it (Sieve stop;).

3. Scheduled sends

Gmail (verified 2026-10-06): compose, click the down arrow next to Send, choose Schedule send, pick a preset or Pick date & time. Scheduled mail sits in the Scheduled folder, where it can be opened, edited, rescheduled, or canceled before it goes out.

Use scheduled send for: landing in someone's morning instead of your midnight, batching outbound mail into two windows so the inbox stays quiet, and deadline-safe sends written ahead of time.

Keep it simple: one send window per audience (work contacts get 9:00 local, personal gets evening), confirm the timezone on the receiving end, and never schedule something that will be stale if the news changes before the send time.

Other providers, keep generic: Outlook desktop has a delay/delivery option on the compose options; Apple Mail and Thunderbird ship a "Send Later" style feature that holds mail until the chosen time. Confirm the exact location before quoting steps for any of these.

4. Templates plus follow-up sequences

Templates live where they are used. Gmail Templates (under Settings > Advanced, then Templates in the compose menu; confirm exact path before quoting) covers recurring answers: introductions, pricing replies, "here is the doc you asked for", meeting confirmations.

A follow-up sequence is a template plus a calendar discipline:

• Touch 1: the ask, one call to action.
• Touch 2 (3 to 5 business days later): the bump, one new reason to care, not a guilt trip.
• Touch 3 (optional, one week later): the close-out, "should I close this out?" gives people a graceful no. Stop on reply. Stop at three. If the third touch gets no answer, archive the thread and move on. A sequence is a courtesy loop, not a drip campaign; it ends.

Keep template files as plain text with a name and a purpose line, so the set survives a provider switch. A good starter set: intro reply, pricing follow-up, meeting bump, polite no, "per my last email" defused into something kind.

5. Auto-responders that do not embarrass

Set a responder that says when mail will be read again, what to do if it is urgent, and nothing else. Two paragraphs max. Include a date. If there is no date, set a calendar reminder to turn it off, or it will greet people for months.

The one rule that matters: never auto-reply to mailing lists. Auto-replying to newsletters and announcement lists creates loops and spam. On Sieve, gate the vacation action on the absence of List-Unsubscribe and on Precedence bulk/list/junk headers; the generator below does this. In Gmail and Outlook, the built-in vacation responders already avoid replying to bulk mail, and test with a second address before going away.

6. Keep the machinery honest

• Every quarter: open the filter list, delete the ones that match senders you no longer get mail from, and check that none of them now match something they should not.
• Keep the export. Gmail's filter export (.xml) goes in a notes folder. For Sieve, keep the script in version control.
• One inbox, one owner of the rules. If two people edit the same filter set, changes collide. Decide who owns it.

Helper script (verified)

Save the following as sieve_gen.py, put the vacation reply text in a file, then run it. It was executed 2026-10-06 and the output is a working Sieve script: requires fileinto and vacation, files receipts and notifications into folders, keeps VIP mail in the inbox, and only auto-responds to direct mail.

python
#!/usr/bin/env python3
"""Generate a starter Sieve script for personal inbox automation.

Usage:
    python3 sieve_gen.py --vacation-days 7 --vacation-msg msg.txt \
        --vip alice@example.com,boss@example.com \
        --receipt-folder Receipts --notify-folder Notifications \
        --out out.sieve
"""
import argparse


def build(vacation_days, vacation_msg, vips, receipt_folder, notify_folder):
    lines = []
    lines.append('require ["fileinto", "vacation", "copy"];')
    lines.append("")
    lines.append("# 1. VIP senders: keep in inbox, stop further processing")
    if vips:
        addr_list = ", ".join(f'"{a.strip()}"' for a in vips)
        lines.append(f'if address :is "From" [{addr_list}] {{')
        lines.append("  keep;")
        lines.append("  stop;")
        lines.append("}")
        lines.append("")
    lines.append("# 2. Receipts and notifications out of the way")
    lines.append(f'if anyof (header :contains "Subject" ["receipt", "order confirmation", "invoice"],')
    lines.append('          header :contains "From" ["no-reply", "noreply", "notifications"]) {')
    lines.append("  if header :contains \"Subject\" [\"receipt\", \"order confirmation\", \"invoice\"] {")
    lines.append(f'    fileinto "{receipt_folder}";')
    lines.append("  } else {")
    lines.append(f'    fileinto "{notify_folder}";')
    lines.append("  }")
    lines.append("  stop;")
    lines.append("}")
    lines.append("")
    lines.append("# 3. Auto-responder for direct mail only")
    lines.append("#    (keeps bulk/list mail quiet; vacation handles reply pacing)")
    lines.append('if not anyof (exists "List-Unsubscribe",')
    lines.append('               header :contains "Precedence" ["bulk", "list", "junk"],')
    lines.append('               header :contains "X-Auto-Response-Suppress" "All") {')
    lines.append(f'  vacation :days {vacation_days} :subject "Away from email"')
    lines.append(f'           "{vacation_msg}";')
    lines.append("}")
    return "\n".join(lines) + "\n"


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--vacation-days", type=int, default=7)
    ap.add_argument("--vacation-msg", required=True, help="path to text file with the reply body")
    ap.add_argument("--vip", default="", help="comma-separated VIP sender addresses")
    ap.add_argument("--receipt-folder", default="Receipts")
    ap.add_argument("--notify-folder", default="Notifications")
    ap.add_argument("--out", required=True)
    args = ap.parse_args()

    with open(args.vacation_msg, encoding="utf-8") as f:
        msg = f.read().strip().replace('"', '\\"')
    vips = [a for a in args.vip.split(",") if a.strip()]
    script = build(args.vacation_days, msg, vips, args.receipt_folder, args.notify_folder)

    with open(args.out, "w", encoding="utf-8") as f:
        f.write(script)
    print(f"wrote {args.out} ({len(script.splitlines())} lines)")


if __name__ == "__main__":
    main()

Output Contract

When this skill fires, deliver:

1. A mail-type inventory (what arrives, grouped by type, with the high-volume automatable types flagged).
2. A filter/rule list, one row per rule: provider, match criteria, action, and why it is safe (what it will never catch).
3. Scheduled-send habits: send windows, timezone note, and any pre-scheduled sends the request named.
4. A template set plus follow-up cadence: template name, purpose, and the 3-touch sequence with intervals and stop rules.
5. Auto-responder copy: two paragraphs, return date, urgent-contact path, plus the mailing-list guard (or the generated Sieve script when the mailbox is self-hosted).
6. A maintenance note: who owns the rules, where the export lives, when the next audit is.

Provider steps may only be quoted exactly when they were verified today. Everything else stays generic, or carries "confirm before quoting".

Operating Rules

1. Stay in the personal-inbox layer. Route manual triage questions to inbox-zero-systems, bulk sending and reputation work to email-deliverability, broadcast copy to email-newsletter.
2. Never invent tools, features, prices, or UI paths. Name only real providers and real mechanics (Gmail filters, Gmail Schedule send, Outlook Rules Wizard, Thunderbird message filters, Sieve). If a third-party automation tool comes up, check its current features before describing them.
3. Preview before creating. In Gmail, click Search on the criteria before Create filter. On Sieve, test against a test folder. No rule ships untested.
4. No delete-all filters. A filter that deletes broadly is a data-loss incident waiting on a typo. Archive and label first; delete only narrow, reviewed patterns.
5. No silent auto-forwarding to outside addresses. Treat it as a decision that needs an explicit word, since it can exfiltrate a whole mailbox if the account is compromised.
6. Auto-responders never reply to lists. Gate on List-Unsubscribe, Precedence bulk/list/junk, and X-Auto-Response-Suppress. Test with a second address.
7. Mark uncertainty plainly. "Confirm before quoting" is always acceptable. A generic-but-true instruction beats a precise-but-stale one.
8. Keep copy tight and human. No em dashes. No hype words, no stacked adjectives, no rhetorical questions answered by the next sentence. Say what the mail does, not what the reader's journey is.
9. Never mention or allude to any human behind the work. No names, no pronouns standing in for a person, no phrasing that points at an owner or operator.
10. Bulk is a sequence, not a skill gap. If an output shows one good rule, ship it; if it shows ten untested rules, cut it to one and verify before adding the rest.