Deep Work: Den Tag für maximale Fokussierung strukturieren

## The real cost of a 2-minute Slack reply
 
Timeline of a "quick" interruption:
 
10:00 — Deep in debugging a race condition
         Mental model loaded: 3 services,
         2 queues, timing-dependent state
10:05 — Slack notification: "Hey, quick question
         about the API response format"
10:06 — Read message, formulate reply
10:08 — Reply sent. Back to code.
10:08 — Wait, where was I?
10:10 — Re-reading the code I was looking at
10:15 — Partially reconstructing the mental model
10:22 — Back to the same depth I was at before
 
Total cost: 22 minutes for a 2-minute reply
 
Over a day with 8 interruptions:
8 × 22 minutes = 176 minutes = ~3 hours lost

## Example daily schedule (deep work focused)
 
┌─────────────────────────────────────────────┐
│ 08:00-08:30  Morning routine                │
│   - Review plan for the day (5 min)         │
│   - Check only urgent messages (10 min)     │
│   - Set intention for deep work block       │
│                                             │
│ 08:30-11:30  DEEP WORK BLOCK 1 ████████    │
│   - Notifications OFF                       │
│   - Slack status: "Focused — back at 11:30" │
│   - Phone face-down                         │
│   - One task, one context                   │
│                                             │
│ 11:30-12:30  Shallow work batch             │
│   - Reply to all messages                   │
│   - Review PRs (time-boxed: 30 min)         │
│   - Quick decisions and approvals           │
│                                             │
│ 12:30-13:30  Lunch (actual break)           │
│                                             │
│ 13:30-15:30  DEEP WORK BLOCK 2 ████████    │
│   - Same focus rules as morning block       │
│   - Often best for creative/design work     │
│                                             │
│ 15:30-16:30  Meetings (batched)             │
│   - Stand-up, 1:1s, planning               │
│   - All meetings in this window if possible │
│                                             │
│ 16:30-17:00  End-of-day routine             │
│   - Process remaining messages              │
│   - Plan tomorrow's deep work task          │
│   - Write down where you left off           │
└─────────────────────────────────────────────┘
 
Deep work hours: 5.5 hours
Shallow work: 2.5 hours
That's a 2.2x ratio — most developers have it inverted

## Task-energy matching
 
### Peak energy (morning, first deep work block)
Best for:
- Complex debugging
- Architecture design
- Algorithm implementation
- Writing new systems from scratch
- Difficult code reviews
 
### Moderate energy (afternoon, second deep work block)
Best for:
- Feature implementation with clear specs
- Refactoring and code cleanup
- Writing tests
- Documentation
 
### Low energy (end of day, between blocks)
Best for:
- Code reviews (straightforward ones)
- Slack responses and email
- Meeting attendance
- Administrative tasks
- Planning tomorrow
 
## Anti-pattern: scheduling your hardest problem for
## 3pm after back-to-back meetings

## Digital environment
 
### Notification audit
Go through every app on your phone and computer.
For each notification channel, ask:
"If I saw this 2 hours later, would anything bad happen?"
 
If no → turn it off.
 
### Communication batch schedule
- Slack: Check at 8:00, 11:30, 15:30
  (3x daily, not 30x daily)
- Email: Check at 11:30, 16:00
  (2x daily)
- Urgent: Phone call or walk over — always available
  (true urgencies don't come via Slack)
 
### Focus mode setup
1. Close all tabs except: editor, terminal, docs
2. Slack → set status, mute channels
3. Phone → Do Not Disturb
4. Music → Consistent background (brown noise, lo-fi)
5. Timer → Start 90-minute block

// A developer's actual focus tracking
// (pseudocode for the concept)
 
interface FocusBlock {
  start: Date;
  end: Date;
  task: string;
  interruptions: number;
  quality: "deep" | "medium" | "shallow";
}
 
function weeklyFocusReport(
  blocks: FocusBlock[]
): {
  totalDeepHours: number;
  avgInterruptionsPerBlock: number;
  bestTimeSlot: string;
  worstTimeSlot: string;
} {
  const deepBlocks = blocks.filter(
    (b) => b.quality === "deep"
  );
 
  const totalDeepMs = deepBlocks.reduce(
    (sum, b) =>
      sum + (b.end.getTime() - b.start.getTime()),
    0
  );
 
  const avgInterruptions =
    blocks.reduce(
      (sum, b) => sum + b.interruptions,
      0
    ) / blocks.length;
 
  // Find which time slots produce the most deep work
  const slotMap = new Map<string, number>();
  for (const block of deepBlocks) {
    const hour = block.start.getHours();
    const slot = `${hour}:00-${hour + 1}:00`;
    const duration =
      block.end.getTime() - block.start.getTime();
    slotMap.set(
      slot,
      (slotMap.get(slot) ?? 0) + duration
    );
  }
 
  const sorted = [...slotMap.entries()].sort(
    (a, b) => b[1] - a[1]
  );
 
  return {
    totalDeepHours: totalDeepMs / 3_600_000,
    avgInterruptionsPerBlock:
      Math.round(avgInterruptions * 10) / 10,
    bestTimeSlot: sorted[0]?.[0] ?? "unknown",
    worstTimeSlot:
      sorted[sorted.length - 1]?.[0] ?? "unknown",
  };
}

## Team agreements for deep work
 
### No-meeting mornings
- No meetings before 12:00 on Tue/Thu
- Everyone knows they have guaranteed focus blocks
- Stand-ups moved to 12:00
 
### Async-first communication
- Default: async (Slack message, document)
- Escalation: mention with @
- Urgent: phone call
- Rule: if it can wait 2 hours, it's async
 
### PR review SLA
- Reviews completed within 4 business hours
- But not immediately — scheduled in shallow work time
- Emergency reviews: use a specific channel
 
### Meeting hygiene
- Every meeting has an agenda and a decision to make
- Default length: 25 minutes (not 30)
- If it's informational only: send a document
- Decline meetings without agendas
 
### Focus status norms
- Red status = deep work, don't interrupt
- Green status = available for questions
- No judgment for being red most of the morning