Internal Comms

Internal Comms is an AI skill for drafting and managing internal company communications including announcements, policy updates, team newsletters, and organizational change messages. It covers message templating, audience segmentation, tone calibration, distribution scheduling, and feedback collection that enable clear and consistent communication within organizations.

What Is This?

Overview

Internal Comms provides structured approaches to creating effective workplace communications. It handles drafting company-wide announcements with appropriate tone and structure, creating policy update messages that clearly explain changes and their impact, composing team newsletters with consistent formatting and section organization, segmenting messages by department or role for targeted relevance, scheduling communication delivery around optimal reading windows, and collecting acknowledgment and feedback from message recipients.

Who Should Use This

This skill serves HR teams communicating policy and organizational changes, department heads sharing updates with distributed teams, executive assistants drafting leadership announcements, and internal communications managers maintaining consistent organizational messaging.

Why Use It?

Problems It Solves

Poorly structured announcements bury critical information, causing employees to miss important changes. Inconsistent tone across communications from different departments confuses the organizational voice. Without templates, each message requires composing from scratch, wasting time and producing variable quality. Lack of acknowledgment tracking leaves leadership unaware whether employees received important updates.

Core Highlights

Message templates ensure consistent structure and tone across all internal communications. Audience segmentation targets messages to relevant groups to reduce information overload. Tone calibration adjusts formality and urgency based on message type and audience. Acknowledgment tracking confirms message receipt for compliance-sensitive communications.

How to Use It?

Basic Usage

from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum

class MessageType(Enum):
    ANNOUNCEMENT = "announcement"
    POLICY_UPDATE = "policy_update"
    NEWSLETTER = "newsletter"
    CHANGE_NOTICE = "change_notice"

class Urgency(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"

@dataclass
class InternalMessage:
    subject: str
    body: str
    msg_type: MessageType
    urgency: Urgency = Urgency.MEDIUM
    audience: list = field(default_factory=lambda: ["all"])
    requires_ack: bool = False
    author: str = ""
    created: str = field(
        default_factory=lambda: datetime.now().isoformat()
    )

class MessageBuilder:
    def build_announcement(self, subject, content, author):
        body = f"Dear Team,\n\n{content}\n\n"
        body += f"Best regards,\n{author}"
        return InternalMessage(
            subject=subject, body=body, author=author,
            msg_type=MessageType.ANNOUNCEMENT
        )

    def build_policy_update(self, subject, changes, effective):
        body = f"Policy Update: {subject}\n\n"
        body += f"Effective Date: {effective}\n\n"
        body += "Changes:\n"
        for change in changes:
            body += f"- {change}\n"
        return InternalMessage(
            subject=subject, body=body,
            msg_type=MessageType.POLICY_UPDATE,
            urgency=Urgency.HIGH, requires_ack=True
        )

builder = MessageBuilder()
msg = builder.build_announcement(
    "Q1 Results", "We exceeded targets.", "CEO"
)
print(msg.body)

Real-World Examples

from collections import defaultdict

class CommsManager:
    def __init__(self):
        self.builder = MessageBuilder()
        self.sent = []
        self.ack_log = defaultdict(set)

    def send(self, message, recipients):
        for recipient in recipients:
            self.deliver(message, recipient)
        self.sent.append({
            "subject": message.subject,
            "type": message.msg_type.value,
            "recipients": len(recipients),
            "requires_ack": message.requires_ack
        })

    def deliver(self, message, recipient):
        print(f"  To: {recipient} | {message.subject}")

    def acknowledge(self, subject, person):
        self.ack_log[subject].add(person)

    def ack_report(self, subject, total_recipients):
        acked = len(self.ack_log.get(subject, set()))
        pct = (acked / total_recipients * 100) if total_recipients else 0
        return {
            "subject": subject,
            "acknowledged": acked,
            "total": total_recipients,
            "percentage": round(pct, 1)
        }

mgr = CommsManager()
policy = mgr.builder.build_policy_update(
    "Remote Work Policy",
    ["Hybrid schedule: 3 days office", "Home setup stipend"],
    "2026-04-01"
)
team = ["alice", "bob", "carol"]
mgr.send(policy, team)
mgr.acknowledge("Remote Work Policy", "alice")
print(mgr.ack_report("Remote Work Policy", len(team)))

Advanced Tips

Create template libraries for recurring message types to reduce drafting time and ensure consistency. Schedule high-importance announcements for morning delivery when readership rates are highest. Use acknowledgment data to identify teams that need follow-up communication.

When to Use It?

Use Cases

Use Internal Comms when drafting company announcements that need consistent structure, when distributing policy updates with acknowledgment tracking, when creating team newsletters with standardized formatting, or when managing organizational change communication campaigns.

Related Topics

Corporate communication strategy, email template systems, organizational change management, employee engagement measurement, and compliance communication requirements complement internal comms.

Important Notes

Requirements

Distribution channels for reaching employees such as email or messaging platforms. Template definitions for each communication type. Tracking mechanism for acknowledgment collection.

Usage Recommendations

Do: include clear action items and deadlines in policy update communications. Segment audiences so employees receive only messages relevant to their role. Track acknowledgment rates for compliance-sensitive communications.

Don't: send high-urgency flags on routine updates, which trains employees to ignore urgency indicators. Distribute lengthy messages without executive summaries at the top. Skip review cycles for sensitive communications that could be misinterpreted.

Limitations

Message delivery confirmation does not guarantee that recipients read the content. Tone calibration for sensitive topics requires human review beyond automated templates. Acknowledgment tracking depends on recipient cooperation and platform integration.