Cut Meeting Time 60% with AI-Powered Async Summaries

// summarizer.ts
import Anthropic from '@anthropic-ai/sdk';

interface UpdateInput {
  author: string;
  content: string;
  timestamp: Date;
  context?: string; // Previous week's summary for continuity
}

async function generateTeamDigest(updates: UpdateInput[]): Promise<string> {
  const client = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY,
  });

  const prompt = `You are summarizing engineering team updates for async collaboration.

INPUT:
${updates.map(u => `
**${u.author}** (${u.timestamp.toISOString().split('T')[0]}):
${u.content}
${u.context ? `Previous context: ${u.context}` : ''}
`).join('\n---\n')}

OUTPUT REQUIREMENTS:
1. **Critical blockers** - needs immediate attention (with @mentions)
2. **Completed work** - group by project, not person
3. **Decisions needed** - format as yes/no questions
4. **Context for next week** - 2-3 sentence summary

Keep it under 400 words. Use bullets, not paragraphs.`;

  const message = await client.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1500,
    messages: [{ role: 'user', content: prompt }],
  });

  // Extract text from response
  const textContent = message.content.find(block => block.type === 'text');
  return textContent?.type === 'text' ? textContent.text : '';
}

export { generateTeamDigest };

// slack-collector.ts
import { WebClient } from '@slack/web-api';

interface SlackUpdate {
  user: string;
  text: string;
  timestamp: string;
}

async function collectUpdates(channelId: string, since: Date): Promise<UpdateInput[]> {
  const slack = new WebClient(process.env.SLACK_BOT_TOKEN);
  
  const result = await slack.conversations.history({
    channel: channelId,
    oldest: (since.getTime() / 1000).toString(), // Slack uses Unix timestamps
    limit: 100,
  });

  if (!result.messages) return [];

  // Filter for updates (ignore threads, focus on top-level posts)
  const updates = result.messages
    .filter(msg => !msg.thread_ts && msg.text) // Top-level only
    .map(msg => ({
      author: msg.user || 'unknown',
      content: msg.text || '',
      timestamp: new Date(parseFloat(msg.ts || '0') * 1000),
    }));

  return updates;
}

# .github/workflows/weekly-digest.yml
name: Weekly Team Digest

on:
  schedule:
    - cron: '0 9 * * 1' # Every Monday 9 AM UTC
  workflow_dispatch: # Manual trigger for testing

jobs:
  generate-digest:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '22'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Generate and post summary
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
        run: |
          node --loader ts-node/esm scripts/digest.ts

# scripts/digest.ts
import { collectUpdates } from './slack-collector';
import { generateTeamDigest } from './summarizer';
import { WebClient } from '@slack/web-api';

const CHANNEL_ID = 'C1234567890'; // Your #team-updates channel
const DIGEST_CHANNEL = 'C0987654321'; // Where to post summaries

async function main() {
  const lastWeek = new Date();
  lastWeek.setDate(lastWeek.getDate() - 7);

  const updates = await collectUpdates(CHANNEL_ID, lastWeek);
  const summary = await generateTeamDigest(updates);

  const slack = new WebClient(process.env.SLACK_BOT_TOKEN);
  await slack.chat.postMessage({
    channel: DIGEST_CHANNEL,
    text: summary,
    blocks: [
      {
        type: 'section',
        text: { type: 'mrkdwn', text: `*📋 Week of ${lastWeek.toLocaleDateString()}*\n\n${summary}` },
      },
    ],
  });
}

main();

**Completed:**
- Shipped user auth refactor (PR #234)
- Fixed memory leak in prod (reduced usage 40%)

**In Progress:**
- Database migration (60% done, on track for next week)

**Blocked:**
- Need design review for dashboard redesign (@sarah)

**Next Week:**
- Start API v2 endpoints

# Before
Total meeting hours: 15h across team
Context-switch events: ~40/week
Time-to-answer questions: 2-3 hours (next meeting)

# After (4 weeks in)
Total meeting hours: 6h (critical decisions only)
Context-switch events: ~15/week
Time-to-answer questions: 30 min (async in digest thread)

# local_summarizer.py
from transformers import pipeline

# Use Llama 3.1 8B (fits on single GPU)
summarizer = pipeline(
    "summarization",
    model="meta-llama/Llama-3.1-8B-Instruct",
    device="cuda", # or "mps" for Apple Silicon
)

def generate_digest(updates: list[str]) -> str:
    combined = "\n\n".join(updates)
    result = summarizer(
        combined,
        max_length=400,
        min_length=200,
        do_sample=False,
    )
    return result[0]['summary_text']