Communication Matrix¶

Philosophy: Async-first, documentation-heavy, respect for deep work time

Communication Channels by Purpose¶

Urgent Issues (Response: Immediate)¶

Channel: Slack/Discord direct message or #urgent channel When: Production down, critical bug blocking team, security incident Example: "API gateway is returning 500s for all requests"

Anti-pattern: Using urgent channels for non-urgent questions

Daily Updates (Response: Within 4 hours)¶

Channel: Async standup (Slack thread, dedicated channel) When: Progress updates, blockers, plans for the day Format:

✅ Yesterday: Completed authentication refactor
🚧 Today: Starting rate limiter implementation
🚫 Blockers: None

Anti-pattern: Skipping updates or making them too vague

Technical Decisions (Response: Permanent record)¶

Channel: Architecture Decision Records (ADRs) in Git When: Architecture choices, technology selection, design patterns Example: "ADR-042: Use WebAssembly for audio processing core"

Anti-pattern: Making decisions in chat that get lost

Code Review (Response: < 24 hours)¶

Channel: GitHub PR comments When: All code changes, documentation updates Format: Constructive, specific, actionable feedback

Anti-pattern: Approving without reading, blocking without explanation

Announcements (Response: Acknowledged)¶

Channel: Email + Slack #announcements When: Team changes, major releases, process updates Example: "New CI/CD pipeline deployed, see docs for migration"

Anti-pattern: Important info buried in casual channels

Brainstorming (Response: Synchronous)¶

Channel: Scheduled video call or voice channel When: Complex problems needing real-time collaboration Before: Share context doc 24h in advance After: Document outcomes in wiki

Anti-pattern: Meeting without agenda, no follow-up notes

Questions & Help (Response: Best effort)¶

Channel: Slack #dev-help or #audio-dev When: Need guidance, stuck on problem, seeking opinions Best practice: Share context, what you've tried, specific question

Anti-pattern: "XYZ doesn't work" without details

Project Coordination (Response: Daily check)¶

Channel: Linear/GitHub Issues When: Task assignment, progress tracking, sprint planning Update: Move tickets through workflow states

Anti-pattern: Stale tickets, unclear ownership

Channel: Team wiki, documentation site When: Tutorials, troubleshooting guides, architecture docs Maintain: Keep updated, link from related discussions

Anti-pattern: Outdated docs, information silos

Channel: Slack #random, #music, #audio-gear When: Building relationships, sharing interests Respect: Work-life boundaries, time zones

Anti-pattern: Pressure to participate, off-topic in work channels

Response Time Expectations¶

Priority	Channel	Expected Response	Example
P0 - Critical	DM/Phone	< 15 minutes	Production outage
P1 - Urgent	Slack mention	< 2 hours	Blocking issue
P2 - Normal	Slack message	< 24 hours	Code review
P3 - Low	Email/Async	< 3 days	Process question

Note: These are expectations, not requirements. Real life happens.

Tool Comparison Matrix¶

Need	Primary	Alternative	Notes
Chat	Slack	Discord	Discord better for voice
Project Mgmt	Linear	GitHub Projects	Linear cleaner UX
Code Review	GitHub	GitLab	GitHub ecosystem lock-in
Documentation	MkDocs	Docusaurus	Static site generator
Video Calls	Zoom	Google Meet	Screen sharing quality
Diagrams	Excalidraw	Mermaid	Excalidraw collaborative

Philosophy: Use what the team agrees on. Tools serve the process, not vice versa.

Communication Guidelines¶

Writing for Async¶

Context first: Assume reader has no prior knowledge
Action clear: What do you need? By when?
Links included: Don't make people search
Timezone aware: "Tomorrow" is ambiguous, use dates

Giving Feedback¶

Specific: "This function could use error handling" not "This is wrong"
Kind: Critique code, not person
Actionable: Suggest alternatives, don't just complain
Balanced: Note what's good too

Asking Questions¶

What you tried: Show your work
What happened: Error messages, behavior
What you expected: Your mental model
Urgency: Is this blocking you?

Escalation Path¶

Try to solve yourself (30 min)
Ask in team channel
Tag specific person if no response in 2h
DM if urgent and blocking
Emergency contact for P0 only

Meeting Policies¶

Default to Async¶

Could this be a doc?
Could this be a Slack thread?
Could this be async standup?

If yes to any: Don't meet.

When Sync is Better¶

Brainstorming complex problems
Resolving conflicts or misunderstandings
Building team relationships
High-bandwidth collaboration

Meeting Requirements¶

Agenda shared 24h before (or meeting cancelled)
Duration capped at 50 min (10 min buffer)
Notes taken and shared after
Action items assigned with owners
Recording available for those who can't attend

No Meeting Blocks¶

Deep work time: 9-12am (no meetings)
Async day: Wednesday (meetings exceptional only)
Time zone respect: No meetings outside 10am-4pm local

Information Hierarchy¶

┌─────────────────────────────────────┐
│ Git (Permanent Truth)               │
│ - Source code                       │
│ - Documentation                     │
│ - ADRs                              │
└────────────┬────────────────────────┘
             │
┌────────────▼────────────────────────┐
│ Wiki (Evolving Knowledge)           │
│ - Processes                         │
│ - Troubleshooting                   │
│ - Learning resources                │
└────────────┬────────────────────────┘
             │
┌────────────▼────────────────────────┐
│ Issues (Work Tracking)              │
│ - Tasks                             │
│ - Bugs                              │
│ - Feature requests                  │
└────────────┬────────────────────────┘
             │
┌────────────▼────────────────────────┐
│ Slack (Ephemeral Discussion)        │
│ - Questions                         │
│ - Updates                           │
│ - Coordination                      │
└─────────────────────────────────────┘

Rule: Important decisions flow UP the hierarchy, never stay in chat.

Examples¶

✅ Good: Async Decision¶

Slack: "I'm thinking we should use Rust for the DSP core.
Writing up an ADR with benchmarks, will share by EOD for feedback."

→ ADR created with data
→ Team reviews async over 2-3 days
→ Decision documented permanently

❌ Bad: Chat Decision¶

Slack: "Should we use Rust or C++?"
Response: "Rust seems cool"
Another: "👍"
→ Decision made, no record, context lost

✅ Good: Asking for Help¶

#dev-help: "Getting segfault in buffer.cpp:142 when processing
512-sample blocks. Works fine with 256. Using latest main branch.
Valgrind output: [link]. Tried increasing buffer size but same issue.
Anyone seen this before?"

❌ Bad: Asking for Help¶

#dev-help: "Code doesn't work, help?"

✅ Good: Update Escalation¶

Async standup: "🚫 Blocker: Need feedback on PR #234 to continue"
→ Wait 4 hours
→ Mention reviewer in PR
→ Wait 2 hours
→ DM reviewer if urgent

❌ Bad: Update Escalation¶

Immediately DM: "Can you review my PR?"

Onboarding New Members¶

Day 1: Introduce in #general, explain communication norms
Week 1: Add to all relevant channels, no pressure to speak
Month 1: Expect comfort with async updates and asking questions

Buddy responsibility: Model good communication, answer questions patiently

Retrospective¶

Every quarter, review: - Are we staying async-first? - Are decisions being documented? - Are response times reasonable? - Do we need to adjust any policies?

Document outcomes in ADR if changing processes.