Focus & Deep Work

Deep Work for Developers: Protect Flow From Reviews, Chat, and CI

A focus system for developers: review windows, small PRs, Slack and GitHub notification settings, CI wait tactics, resume breadcrumbs, and a team agreement.

Ask this guide

Answers come straight from this guide’s text. Nothing is generated, and nothing you type leaves your browser.

A developer's day is cut up by three things that generic focus advice ignores: review requests a teammate is waiting on, chat threads that might be an outage, and CI runs that leave you idle for exactly long enough to open something else. "Turn off notifications and block your calendar" fails because some of those interruptions are other people's real blockers.

Cal Newport describes deep work as focusing without distraction on a cognitively demanding task. For a developer that means holding a design in your head long enough to change it, without leaving colleagues waiting longer than they should.

This guide builds a developer version from research on programmers' work and Google's published review practices: review windows, a pull-request size rule, Slack and GitHub settings, CI-wait tactics, resume breadcrumbs, and a team agreement.

What the research says about programmers' interruptions, and where it stops

Agency, not silence. Meyer, Barr, Bird and Zimmermann analysed 5,971 responses from Microsoft developers on what made a workday good and typical. Their central finding is agency: control over whether the day goes to plan or is disrupted from outside. Meetings and interruptions were unproductive during development but common and constructive in planning, specification and release. It is one company and self-reported, so treat it as a pointer to choose when interruptions land, not to abolish them.

Restarting after a gap is slow, in IDE data from 2005. Parnin and Rugaber analysed about 10,000 recorded sessions from 85 programmers (12 in Visual Studio, 73 in Eclipse), starting a new session after any break of 15 minutes or more without IDE activity:

  • Only 10% of sessions with an edit had coding start within a minute.
  • In the Visual Studio subset (1,213 sessions with an edit), only 7% reached the first edit without navigating elsewhere.
  • About 30% took over 30 minutes to reach the first edit; the authors suspect much of that is debugging.

They call every figure an upper bound, because some of the lag is thinking about a new task, and their data cannot say how short a break must be before the cost appears. This is not the "23 minutes" folklore, which we take apart separately.

No single number says the day worked. The SPACE framework (Forsgren, Storey, Maddila, Zimmermann, Houck and Butler, 2021) says developer productivity cannot be reduced to one metric. It recommends metrics from at least three of its five dimensions, including a perceptual one such as a survey, and names the trade-off this guide lives inside: cutting your interruptions may "block others' work".

A day with two build blocks, two review windows, and an hourly chat glance

This is an example schedule; shift it around your meetings. Chat stays closed inside build blocks and gets an hourly glance outside them; review requests wait for the two windows.

Time Block Rule
09:00 Start-up, 15 min Read yesterday's resume note, skim chat and the GitHub inbox once, write one goal
09:15 Build block 1, 2 h Chat paused, one task, CI waits go to a parking list
11:15 Review window 1, 20 min Review requests first, then chat
11:35 Lunch, meetings, support Cluster meetings here; glance at chat on the hour
13:30 Build block 2, 2 h Same rules as block 1
15:30 Review window 2, 20 min Last chance for a same-day first response
15:50 Shallow work, wrap-up Write tomorrow's resume notes

The time-blocking guide covers buffers and re-planning a broken day.

Size the windows from review data

Two 20-minute windows come to about 3.3 hours a week, some of it spent on chat. In Google's review logs, developers averaged 3.2 hours a week reviewing (median 2.6), the median developer reviewed 4 changes a week, and the median change was 24 lines. Say you get 10 requests a week at 15 minutes each: that is 2.5 hours, which two windows hold.

Windows trade speed for focus. At Google, authors waited a median of under an hour for first feedback on small changes. Here, a request landing at 15:31 is skimmed at 09:00 and gets its full look at 11:15, nearly 20 hours later: inside Google's one-business-day ceiling, which its guide glosses as first thing the next morning, but far slower than Google's measured medians. That guide also tells reviewers mid-task to wait for a break point. Count your reviews for two weeks; if they do not fit, lengthen the windows or add a third.

Tip: Put both windows on your calendar as busy and tell the team the times. A window nobody knows about looks like slowness.

Keep pull requests small enough to finish inside a window

As a rough guide of ours, a 20-minute window has room for two or three small reviews, not one 900-line one. Google's guide on small changes calls roughly 100 lines usually reasonable and 1,000 usually too large, and describes stacking: send a small change, then start the next on top of it, so you keep building while the first waits. Open unfinished work as a draft: GitHub's docs say code owners are not automatically requested on drafts.

Slack and GitHub settings that cut noise without hiding you

Names below match Slack's and GitHub's help pages as of October 2026. Both rename things, so search their docs if a label differs.

Tool Setting Suggested use
Slack Profile picture > Preferences > Notifications > What to notify you about Choose "Mentions and direct messages" instead of "Everything"
Slack Channel keywords Add service names and "incident"; exact matches only, case ignored
Slack Profile picture > Notifications > time frame, or /dnd until 11:15 Pause for a build block; /dnd off resumes
Slack Preferences > Working hours > Allow notifications Set weekdays or custom hours as a recurring schedule
GitHub Repository Watch menu > Custom Tick only the event types you act on
GitHub Inbox filters Defaults include review requests; up to 15 custom filters; Done clears items
GitHub Notification settings > System > Actions In the "Don't notify" dropdown choose "Only notify for failed workflows" (watched repositories)
GitHub Settings > Integrations > Scheduled reminders Slack message listing review requests waiting on you, set per organization

Scheduled reminders fit review windows: pick times shortly before each, such as 11:00 and 15:00. You create one per organization with the pencil icon, then Authorize Slack workspace, days, times and Create reminder; if you cannot, open the review-requests inbox filter at the start of each window.

One failure mode: if production alerts arrive as bot posts in a channel, "Mentions and direct messages" can silence them. Keep that one channel on "All new posts", or route real alerts to the pager.

Pausing does not hide you: Slack shows a snooze icon next to your name, and a sender can override the pause for an urgent direct message, once per day. For macOS Focus modes and Chrome, see the 30-minute notification audit.

What to do during a short, medium, or long CI wait

Nielsen put about 10 seconds as the limit for keeping a user's attention focused on an interface; for longer delays, people want to do other tasks. CI is not an interface, so this is an analogy, but the pull is the same: your attention leaves unless you give it somewhere to go. The thresholds below are our rule of thumb, not measured cut-offs.

Wait Do this Avoid
Under 2 minutes Stay in the change: re-read your diff, tidy the PR description, update the resume note Chat, feeds, starting another task
2 to 10 minutes One item from a parking list that needs no setup: answer a review comment, name the next test Anything needing a new branch or checkout
10 minutes or more Treat it as a switch: write the resume note, hold a review window or take a break, return at the noted time Starting work you cannot park in 30 seconds

Three ways to shrink the wait you sit through:

  • Let the terminal tell you. gh pr checks --watch --fail-fast follows your branch's pull request checks until they finish and stops at the first failure, so you are not refreshing the Actions tab.
  • Let the merge happen without you. With required reviews and status checks configured, auto-merge merges once they pass. "Enable auto-merge" appears only on pull requests that cannot merge yet.
  • Catch the reflex. If you open a feed during every wait, a blocker that adds friction can catch it. FocusWall Pro, a Chrome extension we build, has a level with a 10-second wait. The parking list works without it, and why graduated friction beats hard blocks explains the idea.

Leave a three-layer breadcrumb before you stop

In the Visual Studio subset of Parnin and Rugaber's data, sessions that resumed in the last method edited restarted in under a minute 35% of the time against 10% across all sessions, but that case covered only 17% of sessions.

DeLine and Parnin's CHI 2010 study surveyed 371 programmers, who leaned heavily on note-taking. In the lab part, developers using either of two automated cues built from recent activity completed their tasks with twice the success rate of those using notes alone; the authors' slides list 15 professional developers and call the difference marginal (p < 0.1). Our inference: lean on records your tools already keep, such as the diff and commit log, and add a note for the intent they cannot show. The layers below are our suggestion, none tested as a package.

  1. At the spot. Leave a RESUME: comment with the next action, or a deliberately red test. On a shared branch, mark the test skipped instead.
  2. In version control. A WIP commit whose message states the state and the next step.
  3. Outside the code. A ticket or PR comment using the one-minute resume note.
git add -u   # tracked files only; run git status first if you created new files
git commit --no-verify -m "WIP: invoice rounding, red test for 3 x 0.335" \
  -m "Next: per-line or per-invoice rounding? ask finance"

--no-verify bypasses the pre-commit and commit-msg hooks, so a slow hook does not delay stopping. Those hooks often run linters and secret scanners, so keep WIP commits on a branch only you use and squash before merge. A CI step that fails on RESUME: markers keeps them off main. Next morning: read the note, run the red test, make the first edit.

When to interrupt, and a one-page agreement to paste into your wiki

When to interrupt a teammate

These rows are our heuristics, not research results.

Situation Channel Reply expected
Production impact, security or data risk Phone or pager Immediately
Blocked after 15 to 20 minutes of trying Written question in the team channel, with what you tried By their next check-in
Pull request needs a look Request review; don't ping Next review window
Design disagreement, unclear requirements Book a short slot At the slot
"Got a minute?" Write the question instead Whenever it is read

A team agreement to paste

Edit the times and thresholds to fit your team. Agree to it for four weeks, then change it.

TEAM FOCUS AGREEMENT (trial: 4 weeks, review on <date>)

Response times
- Review requests: first response within 1 working day,
  usually at the next review window (11:15 or 15:30).
- Chat: answered at the next check-in, not within minutes.
- Urgent = production impact, security or data risk, or a
  blocked release. Urgent goes to pager or phone, not chat.

Writing it down
- A question states what I tried, what I expect, what I need by when.
- A PR states what changed, what to check first, how to test.
- Aim for PRs a reviewer can follow in 20 minutes. Split or warn.

Protected time
- Build blocks 09:15-11:15 and 13:30-15:30. Chat paused, status
  says "heads down until HH:MM". Meetings go in the gaps.

Escape hatch
- Anyone may override a pause for something urgent. Overuse is a
  signal to fix this document, not to blame a person.

How we will judge it
- Time to first review, a weekly 1-5 "I could stay in flow"
  survey, number of urgent pings. Not commits or hours online.

The last block follows SPACE's advice to mix measures, one perceptual and the rest from system data; commits or time online would only reward looking busy. To get time to first review, run this gh pr list snippet in a repository:

gh pr list --state merged --limit 30 --json number,createdAt,author,reviews --jq '
  .[] | . as $pr
  | [$pr.reviews[] | select(.author.login != $pr.author.login) | .submittedAt]
  | select(length > 0)
  | {pr: $pr.number,
     hours: (((min | fromdateiso8601) - ($pr.createdAt | fromdateiso8601)) / 3600 | floor)}'

It counts clock hours including nights and weekends, and a bot's review counts, so read the trend, not single numbers. Pull requests nobody else reviewed are skipped.

Where to start this week

  • Monday: put two review windows on your calendar.
  • Tuesday: change the settings in the table above.
  • Wednesday: write one WIP commit with a next step before lunch.
  • Thursday: bring the agreement to your team and propose a trial.
  • Friday: run the time-to-first-review snippet, compare it with how the week felt, then adjust.

Frequently asked questions

What if my team expects replies within minutes?

Start with what you control: pause for one block, set a status with the return time, and rely on the urgent override for real emergencies. Run it as a two-week trial and report time to first reply next to how the block went.

Doesn't batching reviews push the interruption onto the author?

It can. Two windows a day, small pull requests, and drafts for unfinished work limit the cost, and authors keep building on the next stacked change meanwhile. If authors regularly wait more than a day, add a window. Across time zones, our suggestion is one window at the start of the overlap and one at the end, with the first-response promise stated in the reviewer's working days.

I am on call or on a support rota. Does any of this apply?

The structure holds with a different split: put the interrupt-driven queue in fixed windows and let only the pager break in. The attention-residue guide has a worked support-rota day.

Sources and further reading