The 200-Word Morning Briefing That Kills Context Switching

You open your laptop. Slack has 47 unread messages. Email has 23. Three GitHub notifications. Two pull requests. Discord, Twitter, Linear, that Google Doc someone tagged you in.

Forty-five minutes later, you remember what you were actually building yesterday.

This is the tax of context switching. Every project handoff, every notification, every "quick question" forces your brain to reload an entire mental model. Studies show it takes 20+ minutes to fully recover from a single context switch. If you're switching contexts six times before 10 AM, you've burned two hours before writing a line of code.

The solution isn't discipline. It's a system that reconstructs your context in 200 words, four sections, 90 seconds.

Here's the exact prompt, the format it generates, and how to wire it into Claude Code so it runs every time you start work.

Table of Contents

1. Why Morning Context Loss Costs You 10 Hours a Week
2. The Four-Section Format That Actually Works
3. The Exact Prompt (Copy-Paste Ready)
4. Wiring It Into Claude Code Startup
5. What Changes After Week One

Why Morning Context Loss Costs You 10 Hours a Week

Context switching isn't multitasking. It's your brain shutting down one operating system and booting another. Rubinstein, Meyer, and Evans measured this in 2001. Every switch carries two costs:

Goal deactivation cost: Your brain has to save the current task's rules, priorities, and next steps.

Goal activation cost: Your brain has to load the new task's entire context from memory.

If you worked on three projects yesterday (backend API, marketing copy, user research analysis), your morning brain has exactly zero of those contexts loaded. You need to rebuild all three before you can decide what to work on.

Most people rebuild context by scrolling. Slack history. Email threads. GitHub. Meeting notes. Notion pages. This takes 30 to 60 minutes because you're not reconstructing context, you're drowning in new inputs.

Analogy: Opening your laptop without a briefing is like a surgeon walking into an OR with no chart, no notes, just vibes and whatever the nurses remember.

The briefing fixes this. Four sections. 200 words. Everything you need to pick up exactly where you left off.

The Four-Section Format That Actually Works

The briefing has four sections. Always the same structure. Never more than 200 words total.

SECTION 1: WHERE YOU LEFT OFF

Two sentences. What you were doing. What state you left it in.

Example: "You were refactoring the authentication middleware to use JWT tokens. You got the login flow working but logout still throws a 500 error."

SECTION 2: WHAT NEEDS YOUR RESPONSE TODAY

Bulleted list. Three items max. These are blockers, questions, or decisions only you can make.

Example:

• Sarah needs design feedback on the new dashboard by 2pm
• Deploy to staging requires your approval
• Client wants to know if the API can handle 10k requests/sec

SECTION 3: WHAT SHIPPED WHILE YOU WERE OFFLINE

Two to three items. Things your team finished, merged, or deployed that change your context.

Example:

• Backend team merged the caching layer
• Marketing published the case study you reviewed

SECTION 4: SUGGESTED FIRST TASK

One sentence. The single thing you should do first based on priority and dependencies.

Example: "Fix the logout 500 error before Sarah's 2pm deadline, then review the caching implementation."

That's it. Four sections. You read it in 90 seconds and you know exactly what to do.

The Exact Prompt (Copy-Paste Ready)

Here's the prompt. You paste this into Claude. You give it access to your Slack, your GitHub, your project management tool, whatever context sources you use.

You are my morning briefing generator. Read my recent Slack messages, GitHub activity, email, and project notes from the last 24 hours.

Generate a briefing in EXACTLY this format:

SECTION 1: WHERE YOU LEFT OFF
[2 sentences max. What I was working on. What state I left it in.]

SECTION 2: WHAT NEEDS YOUR RESPONSE TODAY
[Bulleted list. Max 3 items. Only things that require MY decision or action.]

SECTION 3: WHAT SHIPPED WHILE YOU WERE OFFLINE
[2-3 items. Things my team finished that change my context.]

SECTION 4: SUGGESTED FIRST TASK
[1 sentence. The single thing I should do first.]

RULES:
- Total word count: 150-200 words
- No fluff, no pleasantries
- Only information that affects what I do in the next 4 hours
- If something isn't actionable or doesn't change my context, omit it

Context sources:
- Slack: #engineering, #design, my DMs
- GitHub: my repos, PRs where I'm mentioned
- Linear: tickets assigned to me or blocked on me
- Email: only from my team or clients

You can adapt the context sources. If you use Discord instead of Slack, swap it. If you use Asana instead of Linear, swap it. The format stays the same.

Wiring It Into Claude Code Startup

The briefing is useful if you run it manually. It's transformative if it runs automatically every time you start work.

Here's how to wire it into Claude Code (or any AI coding assistant that supports startup scripts):

Step 1: Create a startup script

In your project root, create .claude/startup.md:

# Startup Routine

1. Generate morning briefing using the prompt in briefing-prompt.txt
2. Display briefing in chat
3. Ask: "Ready to start on the suggested first task?"

Step 2: Store the prompt

Create briefing-prompt.txt with the exact prompt from the previous section.

Step 3: Configure Claude Code

In your Claude settings, point to the startup script:

{
  "startup": {
    "enabled": true,
    "script": ".claude/startup.md",
    "autoRun": true
  }
}

Step 4: Connect your context sources

Give Claude read access to:

• Your Slack workspace (use Slack's OAuth)
• Your GitHub repos (personal access token)
• Your project management tool (API key)
• Your email (if you want email included)

You do this once. After that, every time you open Claude Code, it:

1. Reads your last 24 hours of activity
2. Generates the four-section briefing
3. Shows it to you immediately

You read it in 90 seconds and you're in full context.

What Changes After Week One

I've been running this system for three months. Here's what actually changed:

I stopped scrolling Slack in the morning. The briefing tells me what I need to know. If it's not in the briefing, it doesn't affect my work today.

I make decisions faster. Section 2 shows me exactly what needs my response. I knock those out first. No more "let me think about it" that turns into three days of delay.

I ship more. The suggested first task is always the highest-leverage thing I can do. I don't waste time deciding what to work on.

I context-switch less. Knowing what shipped (Section 3) means I don't get surprised by changes. I adjust my plan once, in the morning, instead of ten times throughout the day.

The biggest change: I stopped feeling behind. That constant low-grade anxiety of "what am I forgetting" is gone. If it matters, it's in the briefing.

Comparison: Manual vs. Automated Briefing

The automated version wins because it removes the activation energy. You don't have to remember to run the prompt. It's just there when you open your editor.

The Real Win: You Stop Managing Inputs

Most productivity advice is about managing inputs better. Better email filters. Better notification settings. Better Slack habits.

This is different. You're not managing inputs. You're delegating input management to an AI that reads everything and tells you only what changes your next four hours.

You still get tagged in 47 Slack threads. You still get 23 emails. You still get GitHub notifications. But you don't read them. Claude reads them. Claude decides what matters. You read 200 words and get back to building.

That's the whole game. Context reconstruction in 90 seconds instead of 45 minutes. Every morning. Forever.

One Last Thing

The format matters more than the content. Four sections. Always the same structure. Your brain learns to parse it instantly.

Don't customize it. Don't add sections. Don't make it longer. The constraint is the feature. 200 words. Four sections. That's it.

Copy the prompt. Wire it into your startup script. Read it tomorrow morning. You'll know exactly what to do.