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-fastfollows 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.
- 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. - In version control. A WIP commit whose message states the state and the next step.
- 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
- Today Was a Good Day: The Daily Life of Software Developers — Meyer, Barr, Bird and Zimmermann, IEEE Transactions on Software Engineering, vol. 47, no. 5, 2021 (online 2019). The 5,971-response study.
- Resumption Strategies for Interrupted Programming Tasks — Parnin and Rugaber, Georgia Tech manuscript, 2009 (the 2011 journal version may differ in counts). Session and edit-lag figures.
- Evaluating Cues for Resuming Interrupted Programming Tasks — DeLine and Parnin, CHI 2010. The 371-programmer survey and cue experiment.
- The SPACE of Developer Productivity — Forsgren, Storey, Maddila, Zimmermann, Houck and Butler, ACM Queue 19(1), 2021. Metric advice and trade-offs.
- Modern Code Review: A Case Study at Google — Sadowski, Söderberg, Church, Sipko and Bacchelli, ICSE-SEIP, 2018. Review hours, change size, speed.
- Configuring notifications — GitHub Docs. Watch options and inbox.
- Pause your Slack notifications — Slack Help Center. Pausing, schedules,
/dnd, urgent override. - gh pr checks — GitHub CLI manual. The
--watchand--fail-fastflags.