1. The Slacking Museum#

2. Taking the Joke Apart: There Are Two Kinds of Slacking#

• Deceptive slacking: decoupling the “activity signal” from “work happening” — manufacturing the former, skipping the latter. The time it buys is borrowed; the creditor is your employer, and the repayment date is uncertain.
• Waiting slacking: your time is stuck inside something that’s genuinely happening — compiling, installing dependencies, waiting on CI, waiting on a deploy, waiting on a colleague’s review. This time isn’t stolen; it’s not yet engineered away.

The two look almost identical on screen (nobody’s typing). The difference is only what you have in hand when you come back:

So the second kind is what’s actually worth studying. The three moves below aren’t new, but they share one thing: while you’re away, things genuinely move forward.

3. Eliminating the “Wait”: Three Levels#

1
# ~/.bashrc — usage: tt pnpm build
2
tt() {
3
  /usr/bin/time -f "%e\t%C" -a -o "$HOME/.tt.log" "$@"
4
}

1
# One week later: waiting-time leaderboard
2
sort -k1,1nr ~/.tt.log | head -20

1
#!/usr/bin/env bash
2
# scripts/dev.sh — one command, one foreground process, Ctrl-C exits everything
3
set -euo pipefail
4

5
# Installing dependencies and bringing up the database never needed to be serialized anyway, so start them at the same time
6
pnpm install --frozen-lockfile &
7
INSTALL=$!
8
docker compose up -d db &
9
DB=$!
10

11
wait "$INSTALL" "$DB"
12

13
# Cleanup: stop the database when the script exits, leaving no orphan processes
14
trap 'docker compose stop db >/dev/null 2>&1 || true' EXIT
15

16
pnpm db:migrate
17
exec pnpm dev

1
- uses: actions/setup-node@v4
2
  with:
3
    node-version: 22
4
    cache: pnpm        # The key is computed by it, so you don't have to write hits/archives by hand
5

6
# When you need to cache things beyond dependencies (such as build artifacts), use the cache explicitly:
7
- uses: actions/cache@v4
8
  with:
9
    path: .next/cache
10
    key: ${{ runner.os }}-next-${{ hashFiles('pnpm-lock.yaml') }}
11
    restore-keys: |
12
      ${{ runner.os }}-next-

1
# Linux: prevent idle sleep while running long tasks, and release it automatically when the task ends
2
systemd-inhibit --what=idle --why="running tests" pnpm test
3

4
# macOS
5
caffeinate -i pnpm test

1
# .git/hooks/pre-commit (remember to chmod +x)
2
#!/usr/bin/env sh
3
pnpm biome check --staged --write || exit 1
4
git add -u

4. Grading the Quality of Slacking#

Not all rest is equivalent. The finding in Gloria Mark’s team’s CHI 2008 paper “The Cost of Interrupted Work: More Speed and Stress” is a bit counterintuitive: after being interrupted, people do finish tasks faster, but at the cost of higher stress and effort — the speed is bought with tension. In her team’s later field observation studies, the oft-cited number is “after an interruption, it takes an average of 23 minutes and 15 seconds to return to the original task,” while people switch activities on average every 3 minutes and 5 seconds, and about half of those interruptions are self-inflicted.

Sio and Ormerod’s 2009 meta-analysis spells out “stepping away” in more detail: incubation does improve problem-solving rates, with divergent tasks benefiting more than verbal/visual insight tasks; the longer the preparation period, the more pronounced the effect. But there are two key moderators:

1. Doing high-cognitive-load tasks during the incubation period significantly weakens the incubation effect;
2. For verbal insight problems, low-cognitive-load filler activities work even better than pure rest.

Translate these two into office language and you get a very practical slacking grading:

• High-quality slacking: low cognitive load + away from the screen. A walk, getting water, washing your cup, looking out the window, chatting about something else. Problems sort themselves out in the background.
• Low-quality slacking: high cognitive load + still staring at the same screen. Short videos, trending topics, switching into a more stimulating feed. Ten minutes later, you haven’t rested, and you owe one more interruption.

Same ten minutes: one is digesting problems for you, the other is manufacturing trouble for you.

As for “work expands to fill all available time” (Parkinson’s law), it’s a reminder about process, not a whip for people: leaving whitespace is safe only when delivery boundaries are crystal clear. When boundaries are fuzzy, whitespace gets filled — and what fills it usually isn’t work, it’s anxiety.

5. Slacking Self-Check List#

Ask yourself four questions before leaving work:

• Over the past week, how much time did I spend “waiting”? Have I measured it?
• Is the time I slacked today earned (via automation) or borrowed (via disguise)?
• When I rest, is the screen on or off?
• If a colleague ran my scripts, would they save time, or would it be more hassle?

Final Thoughts#

Jigglers will keep selling, memes will keep circulating. But be clear in your mind: the highest form of slacking isn’t making others think you’re working — it’s that while you’re away, the work keeps moving forward.

The problem with a mouse jiggler isn’t that it costs ten yuan — it’s that it only forges “someone is pushing forward,” while nothing actually gets pushed forward. A good set of scripts is exactly the opposite: in those twenty minutes you’re away, dependencies finish installing, the cache hits, the migration completes, the tests finish running — your absence is backed by the pipeline.

So next time someone asks “what were you just doing,” the best answer isn’t “I was running a build,” but:

I was running a build. And it went from 47 seconds down to 4.

References#

• US bank Wells Fargo fires employees for ‘simulating’ being at their keyboards — The Guardian
• Wells Fargo fires workers over fake keyboard activity — BBC News
• The Cost of Interrupted Work: More Speed and Stress — Mark, Gudith & Klocke, CHI ‘08
• Does incubation enhance problem solving? A meta-analytic review — Sio & Ormerod, Psychological Bulletin, 2009
• Dependency caching reference — GitHub Docs
• Parkinson’s law — Wikipedia

Further reading: there are several other posts on this blog about “time and process” — Command Line Tips: 20 Commands to Boost Terminal Efficiency, The Classic Programmer Time Estimation Joke: Always Twice as Slow as Expected, and The Friday Deploy Curse: Superstition and Incidents on Release Day.