How to Group Similar Tasks and Do Them Together (Do It)

We have a familiar morning scene. We open our laptop, and it greets us with a thicket of tabs we barely remember planting. A ping from a chat pulls our eye. We answer, then notice a bill reminder, then an email about a form, then a draft that needs two paragraphs, then a calendar invite that wants a decision. Ten minutes later, we have touched five things, finished none, and feel strangely breathless for someone sitting still. We glance at the time and quietly choose a different rhythm: we cluster the similar items and run them as a group. The act feels small, almost clerical, but we notice within an hour that our attention behaves better when it doesn’t jump lanes.

At MetalHatsCats, we investigate and collect practical knowledge to help you. We share it for free, we educate, and we provide tools to apply it.

Background snapshot: The practice of grouping similar tasks—“batching”—has roots in manufacturing and cognitive psychology. Assembly lines reduced changeovers to cut waste; we can do the same with mental set-shifts. The common trap is to batch vaguely (“do admin”) and let urgent items leak into the block, creating a muddy session that feels busy but produces little. Another failure mode is over-batching: we create giant blocks we can’t start or finish, then avoid them. Outcomes change when we define crisp categories, cap block lengths (20–90 minutes), and close input gates during the block. It also helps to measure just one or two numbers: how many batches we completed and how many context switches we avoided.

We will not propose a life overhaul. We will propose a decision that fits inside today. We name two to four categories we already do, schedule short blocks, and run them without letting our attention stray. The aim is less switching, more finishing. The tone is firm and kind; we will bump into the same old frictions and keep walking.

We begin by sketching a day.

We have errands by phone (call the dentist, renew a prescription). They are all the same shape: small, verbal, often with waiting time. We also have messages: a dozen emails, three DMs that need an answer longer than “yes”, two comments in a shared doc. And there is the “paperwork” layer: pay two bills, upload a receipt, rename and file three PDFs, update a spreadsheet line. Finally, there is one medium creative task: outline 600 words for a memo. If we process these as they appear, our mind will skid across surfaces. If we batch, we give it rails: one lane for calls, one for messages, one for admin, one for writing.

We square this with known costs. Switching attention is not a free move. In lab and field studies, people spend anywhere from 10 to 25 minutes regaining full context after an interruption; Gloria Mark’s field work places average reorientation time at about 23 minutes after a major switch. Even micro-switches cost seconds that ladder up; if we switch lanes every three minutes over a 60-minute period, we lose 10–20 minutes to friction. We do not need to be purists to capture most of the win: two or three clean batches can reclaim an hour we used to leak.

We set a behavioral target we can measure today:

• Complete 2–4 task batches (each 20–45 minutes).
• Limit unplanned context switches to 10 or fewer during work hours.
• Finish at least one cluster fully to closure (no “almost”).

If we fear structure because it looks rigid, we can think of this as time-limited containers. We pour similar pebbles into one jar and shake until they settle, then we stop. We do not force perfection; we aim for countable, done.

Small scene: It is 9:10. We open Brali LifeOS and select “Batch: Messages” for 30 minutes. We enter three filters: email subjects containing “invoice,” chat threads with red dots, and all comments assigned to us today. We also set a rule: we will not click links that spawn new projects; we will log them for later. The timer is visible; our phone is face down in another room. The first five minutes feel itchy—our brain tries to wander. But after the second message, a rhythm forms: read, reply, archive. In 28 minutes, we clear 14 messages. We avoid four near-detours (a link to a long doc, two newsletters, a Slack channel full of jokes). We write two three-sentence responses that move a decision forward. At 9:40, we leave some messages unread. We feel a hint of frustration, then notice the relief of a natural stop. We capture the next batch’s candidate tasks and press done.

The practice is less about speed and more about managing cognitive mode. Messages ask for quick parsing, context-light choices, and concise writing. Calls require voice energy, patience with hold music, and certain scripts. Admin prefers a mechanical rhythm. Writing asks for deeper concentration and a quieter environment. By grouping, we keep our mind in one mode long enough to produce momentum.

We will follow the thread in ordinary language, with specifics.

Naming the buckets

We start where we are. We open yesterday’s task list and skim for sameness. The categories we choose will be boring on purpose, because that boring-ness makes them easy to sort and repeat. Common examples:

• Messages: email replies, DMs, comment replies.
• Calls: outbound calls, voicemails, scheduling, follow-ups.
• Admin: bills, expense uploads, filing, renaming, calendar tweaks.
• Errands: short physical movements in one neighborhood or area.
• Writing/Thinking: outline, draft, revise, edit one piece of work.
• Maintenance: code reviews, inbox zero, backups, updates.

We choose at most four for today. More than four becomes a sorting project. Less than two sounds unrealistic for most days unless we are in a heavy build phase. We pick three: Messages, Calls, Admin. If we have one significant creative task, we add Writing as a fourth; otherwise, we commit to finishing the first three.

We decide block lengths based on content. A message batch is often 20–40 minutes. A call batch can range from 15 minutes (two quick calls) to 60 minutes (three calls with hold times). Admin batch is often 25–45 minutes. Writing can be 25, 45, or 90 minutes depending on capacity. For our example day, we make these choices:

• Messages: 30 minutes at 9:10.
• Calls: 40 minutes at 10:00.
• Admin: 30 minutes at 11:00.
• Writing: 45 minutes at 14:00.

We document the decision in Brali so we can measure later. Tiny repetition builds trust.

The practical constraint: interruptions

Real life interrupts. Children, colleagues, alerts, the doorbell. We do not pretend these disappear because we declared a batch. We apply a triage rule:

• Hard interruption (urgent, must respond within minutes): allow, log, resume batch if possible.
• Soft interruption (can respond within hours): capture in a quick “Later” list inside Brali, do not act now.
• Habitual interruption (we open a fun tab): notice, close, record as a context switch.

We set the Brali check-in to ask one daily question about switches we avoided. We count because count changes behavior. When we know we are logging “switches avoided,” it becomes a small game with our own impulses. If we avoided seven, we try for eight tomorrow, without moral drama.

A note about friction. Some tasks look similar but have hidden differences. A “reply” might be trivial (“received, thank you”) or heavy (a decision with stakes). We treat these not by hope but by classification. Heavy replies are not messages; they are “mini-decisions” or “micro-writing” and belong in a writing block. If we classify honestly, we protect the message batch from turning into a thinking swamp.

We assumed “reply” meant “quick” → observed that two replies required substantial analysis → changed to classify “decision replies” into the Writing block. This small pivot keeps trust in the bucket.

The cost and the payoff, in numbers

We quantify so our future self believes this is not theater. If we normally check email 12 times a day for two minutes each, that’s 24 minutes of scattered time plus 12 reorientation moments. If we run two 15-minute message batches instead (30 minutes total), we may spend six minutes more in pure handling time but save 12–20 minutes of switching friction. If we measure our “context switch” count (a simple tally)—say we drop from 30 to 15 in a day—we can infer a 15 × 20–60 second savings, that is 5–15 minutes back, plus the larger blocks’ momentum.

Another place to quantify: calls. If we wait on hold twice, each 4 minutes, we can fill that time with adjacent micro-admin tasks if we planned them into the same block. That yields a double use of waiting minutes. We log this so we can remember the feeling of efficient calm during a block.

The tactic inside the tactic: pre-stack

A batch works better when we pre-stack the items. We spend three minutes to gather the to-dos and line them up. A Messages pre-stack might be a Brali list filtered by “today” and tag “messages.” A Calls pre-stack might have three numbers and scripts: “Hi, I’m calling to confirm…,” “Could you send me a copy…,” “Please cancel….” The Admin pre-stack is a staging folder with PDFs to rename and file, and a bank tab already open.

We can create a tiny script for each block. For example:

• Messages script: scan top to bottom, use 3-sentence rule, archive or schedule follow-up, no link-holes.
• Calls script: dial, leave voicemail if no answer, note next action in Brali, next number immediately.
• Admin script: two-minute bills first, then receipts, then rename and file.

We keep each script under 30 words. The point is to remove micro-decisions, not to add bureaucracy. We write the scripts once, then copy-paste into the Brali batch description so the standards live where the work happens.

Mini-App Nudge: In Brali LifeOS, turn on “Batch Gate.” It hides tasks outside the active batch for 30–45 minutes. One toggle reduces 80% of in-block temptation.

A day in movement: micro-scenes

We stand at the counter at 9:55, pour water, and open the Calls block. Three items sit ready. First is the pharmacy. We dial. Hold music. While waiting, we open the Admin staging folder and rename “IMG_4321.jpg” to “2025-01-11_receipt_stationery_14.50.pdf” and drop it into the “Receipts > Jan 2025” folder. The call connects; we return to voice. Two minutes later, we have a refill confirmation. We hang up and press the next number. Voicemail. We leave a clear message with our number twice, log “waiting reply,” and move to the dentist. The receptionist answers, we reschedule, we smile at the relief of the checkmark. The timer shows 33 minutes used. We have done “nothing major,” yet we freed the next two weeks from tiny nagging.

At 11:00, Admin. We batch bills. We open two tabs, enter numbers (amounts: 62.17, 149.00), confirm, download PDF confirmations, file. Five receipts: value 7.95, 14.50, 39.00, 8.30, 12.20. Rename, drop in place. We update a spreadsheet line with a 14.50 charge and tag “stationery.” It takes 26 minutes because we pre-staged. We feel calm; we notice that the second bill felt faster than the first because our motor memory warmed up.

Afternoon writing. We block 45 minutes to outline a memo. We set a tiny instruction: only outline, do not draft. We reserve drafting for tomorrow’s writing block. Fifteen minutes in, a message preview tugs at our attention. We see the familiar pull and tell ourselves, “In 30 minutes.” The choice costs 3 seconds of discomfort and saves 10 minutes of derail. We log “switch avoided: 1.” The outline reaches nine bullets. Not perfect, but real, and aligned with the block’s scope.

The common traps, and how we step around them

Trap one: “Batching becomes procrastination theater.” We can spend more time organizing than doing. We set a hard limit: pre-stack time is capped at 3 minutes for small batches, 5 minutes for writing. If we begin rearranging for longer, we stop and start the batch anyway. The imperfect queue is better than the perfect delay.

Trap two: “Too many categories.” If we make nine buckets, we face sorting fatigue. We fix by choosing a daily maximum of four categories. If we find a fifth candidate, we ask if it can fit in an existing bucket or wait until tomorrow.

Trap three: “Over-batching the hard thing.” We may declare a 3-hour writing batch and then avoid it. We invert: set a 25-minute writing block with an insultingly small scope (write the first paragraph; produce five bullet points). We let success raise the weight over days. Our brain learns that writing is survivable, even pleasant.

Trap four: “Letting inputs leak in.” During a Messages block, we open an unread newsletter and descend into a 20-minute article. We counter with a parking lot: a Brali list called “Later Reading” that we populate with one tap. We quantify: if reading exceeds 1 minute, it goes to Later. We build a boundary we can respect.

Trap five: “Batching discreet tasks that are actually heterogeneous.” A “proposal revision” and a “form submission” both live under “work,” but one needs deep thinking, the other needs patience for forms. We split by cognitive mode, not by project label.

A deliberate pivot in our week

We assumed running email all morning would make us feel “on top.” We observed that our afternoons were hollowed out, with creative work deferred and energy low, despite the satisfying reduction in unread counts. We changed to a fixed morning Messages batch (30 minutes) and a short mid-afternoon Messages sweep (15 minutes), preserving the late morning for Admin or Writing and early afternoon for deeper work. After three days, we counted 60–90 minutes reclaimed for substantive work, with no meaningful drop in responsiveness. The count we watched changed our behavior more than a generic resolution could.

Edge cases and how we handle them

• Reactive roles. If our job requires real-time responsiveness (support, trading, newsroom), batching can look irresponsible. We negotiate boundaries: a colleague covers for a 30-minute deep block; we keep an on-call lane but still cluster non-urgent items. We use status indicators to signal availability. We measure response-time percentiles to ensure we remain within expectations (e.g., 90% of messages answered within 2 hours).

• Parent care and domestic unpredictability. If our day is punctured by needs we cannot schedule, we shrink batches to 10–20 minutes and pick categories that can be paused without hurt—Admin and Messages instead of Writing. We keep a “resume token”: a single sentence at the top of a draft noting where to pick up. It cuts restart cost by 30–60 seconds, which matters in 10-minute windows.

• ADHD and attention variability. Batching can reduce decision fatigue, but long blocks can feel punishing. We use shorter blocks (10–25 minutes), high-friction gates (app blockers), and explicit switch credits: we allow one 60-second “novelty flick” between items without shame. We log it so the pattern is visible and then adjust.

• Teams and shared calendars. Our batch plans crash into meetings. We convert passing minutes into micro-batches: three 8-minute windows can clear five quick messages. We also schedule one weekly 60–90-minute “Supportive Admin” block during a low-meeting hour, communicating it to the team. Once colleagues see consistent outcomes (invoices paid same day, approvals within 24 hours), the block earns respect.

• Emergency days. Some days are all fire. We adopt the 5-minute alternative path (below)
  to protect the habit identity without pretending to do real batching.

Designing the categories well

We evolve our categories with two heuristics:

1. Same tools, same mode. If two tasks use the same app and the same kind of thinking, they likely belong together.
2. Finishable within 45 minutes. If a “task” cannot meaningfully progress inside that window, it belongs in a different plan (e.g., a dedicated project block).

We test with a simple yes/no: could we do the next three items back-to-back without opening new tools? If no, we refine the category.

We attach simple, measurable completion criteria. For Messages: “Archive down to 10 unread or fewer.” For Admin: “File all receipts in the staging folder.” For Calls: “Reach three humans or leave three voicemails.” For Writing: “Produce an outline with 7–10 bullets.” These criteria remove the anxiety of open-endedness and produce a finish line we can hit.

Tools and environment, tuned lightly

We do not over-gear. A timer, a filtered task view in Brali, and a staging folder cover 90% of needs. Optional helpers: a site blocker for the Messages batch (to block news and social), a phone in another room during Writing, a sticky note with the batch script. If we use noise or music, we pair them with categories (lofi for Admin, silence for Writing, none for Calls). The pairings become anchors.

We adjust the environment in the first minute of each batch: close unrelated windows, open necessary tabs, set the timer, check the script. It is the equivalent of washing a cutting board before chopping the next ingredient. The minute pays for itself quickly.

The 80/20 gains: limit the input gates

We discover that the biggest wins come from closing gates while we batch: shut email during Writing; mute Slack during Calls; silence phone during Admin (unless calls are part of it). If we cannot close a gate because of role constraints, we set a lighter rule: we only glance at notifications at the 10-minute mark. That small delay breaks the compulsion loop and retains focus.

What about creative tasks?

Some resist batching because it feels industrial, and they fear it will flatten creative moments. Our experience suggests that light batching protects creative time rather than harms it. By clustering the low-stakes support work, we free a clean 45–90-minute window for thinking. We define the scope (outline, not final draft; sketch scenes, not full chapter). We keep the block gentle. The absence of tiny “pings” becomes a kindness to the mind.

If we are unsure, we experiment. We run a week with one 45-minute writing batch a day at the same hour. We measure output (bullet count, word count), difficulty (1–10), and satisfaction (1–10). We observe the curve. If it lifts, we keep it. If not, we adjust (time of day, shorter blocks, different scope).

A simple daily plan

We propose a skeleton we can reuse:

• Choose 2–4 categories.
• Assign 20–45 minutes to each.
• Pre-stack items for 3 minutes.
• Run the batch with a tiny script.
• Close with a single line of review: “What pulled, what helped?”

We put this in Brali as a template. The app stores the categories, scripts, and timers, so we press “Start” instead of rebuilding mentally.

Sample Day Tally (target: 3 batches; 2 hours total; ≤10 unplanned switches)

• Messages (30 minutes): 14 items answered; 2 deferred; 4 switches avoided; timer 30:00.
• Calls (40 minutes): 3 calls completed; 1 voicemail; 2 receipts filed during hold; timer 39:12.
• Admin (30 minutes): 2 bills paid (62.17; 149.00); 5 receipts filed (7.95; 14.50; 39.00; 8.30; 12.20); 1 spreadsheet line updated. Totals: 100 minutes batched; 9 unplanned switches recorded (target ≤10 met); 1 Writing block deferred to tomorrow.

We do not fetishize perfection. The point of a tally is to see reality and adjust.

Misconceptions to dissolve gently

• “Batching is just time blocking.” Overlap exists, but the emphasis differs. Time blocking schedules everything; batching groups by similarity to reduce cognitive switching. We can time-block batches, but we can also drop a batch into an open window without planning the entire day.

• “Batching kills spontaneity.” It does reduce spontaneous task-switching, which we often mislabel as spontaneity. We keep a small sandbox: a 10–15-minute unstructured slot where we can follow a curiosity thread deliberately.

• “Only suits office work.” Batching makes sense in households (laundry, dishes, meal prep), learning (review all flashcards, then do all practice problems), fitness (superset similar movements), and healthcare admin (book, confirm, list questions).

• “I’ll lose responsiveness.” If we choose 2–4 short batches and set a small sweep in the afternoon, most people remain within expected response times. We can also add an “urgent lane” that bypasses batching with clear criteria.

One explicit cost: boredom

Grouping tasks can feel dull. The reward is a square of quiet after a module is done. We can sweeten the batch ethically: a specific playlist for Admin, a favorite tea for Messages, a nicer pen for Calls notes. We log the small pleasure as part of the ritual; it becomes a humane glue.

One explicit risk: over-commitment to the plan

We can fall in love with the method and try to force a batch when a flexible response would be wiser. If a teammate needs a quick brainstorming session that could unblock their day, we may drop our Admin batch to help. We then schedule a compensatory micro-batch (10 minutes) later. The method exists to support outcomes, not to cage us.

A week of calibration

Day 1: We run three batches. We notice that our Messages block runs long because we included two decision-heavy replies. We mark those for Writing next day.

Day 2: We run two batches and one writing block. Energy dips mid-afternoon; we test swapping Writing to morning. We assume we are morning-sharp; we observe a 15% increase in output (from 9 bullets to 11); we change to morning writing.

Day 3: Meetings crush the day. We protect a 20-minute Admin micro-batch at lunch. It clears bills and receipts. Not glamorous, but it prevents backlog.

Day 4: We add a 15-minute late-afternoon Message Sweep to close loops. It drops our evening rumination by 1–2 points on a 10-point scale.

Day 5: We reflect and standardize: Messages 09:15 (30 min), Writing 10:15 (45 min), Calls 13:30 (30–40 min), Admin 16:00 (25 min). We leave Friday afternoon open.

We use Brali to copy the structure into next week. The calendar is not a prison; it is a path with resting stones.

How to start today (10 minutes or less)

• Minute 0–2: In Brali, pick 2 categories you already have tasks for (e.g., Messages, Admin). Add them as “Batch: Messages (30)” and “Batch: Admin (25).”
• Minute 2–4: Pre-stack: filter tasks by tag; drag 5–10 items into each batch list.
• Minute 4–5: Write a one-line script for each batch (“3-sentence replies, archive or schedule; no links”).
• Minute 5–10: Run the first batch for five minutes to break the seal. Stop before it hurts. Log “Batch started” and one observation (“Links pulled hard; the script helped”).

If we do only this, we built the habit’s handle. We can grip it again tomorrow.

Advanced move: compound batches

Sometimes two categories pair well: Calls + Admin. The gaps in a call block (holds, transfers)
are perfect for micro-admin tasks that require only a glance and a click. We keep the admin staging folder open and bounce lightly during waits. We do not attempt deep admin tasks; we reserve those for the Admin block. This compound move turns dead air into tidy returns. We measure: how many minutes of hold reclaimed, how many admin items cleared in parallel.

Designing the rules as experiments

We write rules as hypotheses. For example:

• Hypothesis: “Two message batches (30 + 15 minutes) keep responses under 4 hours during office time.”
• Measure: average and 90th percentile response time.
• Adjustment: if the 90th percentile slips beyond 6 hours, add a 10-minute midday sweep.

Or:

• Hypothesis: “Writing first thing reduces avoidance.”
• Measure: subjective difficulty (1–10), output (bullets/words), start time consistency.
• Adjustment: if we miss two consecutive mornings, shrink the block to 20 minutes and restrict scope.

We treat rules like software: versioned, reversible, and judged by data.

When batching fails

We will have a day when we drop into a message block and emerge two hours later with a strange feeling of accomplishment and dread. We realize we let the batch absorb items outside its scope. We feel annoyed at ourselves. We resist a self-lecture; we write down what happened. “Open doc link → read 14 minutes → copied two points → lost half the block.” We then set a guard: “During Messages, any doc longer than 90 seconds → add to Writing with a tag.” We also set a visual barrier: open email in a smaller window; it becomes harder to wander. It’s not foolproof. It’s humane.

Another failure: we stacked too much into Admin and ended the day with a sore brain. We shrink tomorrow’s Admin to 20 minutes, and we move one category to tomorrow. The habit is not a sprint but a cadence; we protect the cadence.

A word on momentum

The odd effect of grouping tasks is that after 10 minutes, we feel a rolling ease. The third email is easier than the first; the fifth receipt rename is almost automatic. We ride that. Momentum is a cognitive gift; we waste it when we switch. Through batching, we honor momentum. The mind thanks us by going faster without a strain feeling.

Socializing the method with others

If we work in a team, we share the plan lightly. “I’m in a calls block until 11; I’ll pick up messages after.” We do not require others to adopt the same method. We explain how and why we will be responsive within certain windows and invite others to set similar expectations. If helpful, we set a shared “Admin Hour” once a week where multiple people batch at the same time—Slack goes quiet, forms get filed, approvals flow. The atmosphere turns from reactive to cooperative.

Particulars we can adopt today

• Rename your “to-do list” sections in Brali to the categories: Messages, Calls, Admin, Writing.
• Pre-write the scripts once. Paste them into each batch template.
• Create a “Staging” folder for Admin on your desktop and a “Later Reading” list in Brali.
• Add a check-in metric: “Batches completed today: [count].” Add another: “Unplanned switches: [count].”
• Use the same start time for one batch daily for a week to test anchoring.

Uneven days and forgiving counts

Some days we will run one batch and count it a win because the room was full of life. We log it. A week later, the chart shows 1, 3, 2, 0, 4, 2, 1. The shape is human. The next week, the lows become 1 and the highs become 3–4. The method becomes less a rule and more a rhythm.

Five minutes on a hard day (alternative path)

• Open Brali’s Batch: Messages.
• Set a 5-minute timer.
• Answer only yes/no or schedule-confirm messages.
• Archive each as you go. Stop at the timer. Log “1 micro-batch” and a single observation.

This keeps the identity loop alive (“we batch”)
without forcing a full session.

Scaling to projects

We can apply batching at the project level: collect similar sub-tasks (e.g., “gather references,” “export charts,” “write figure captions”) into adjacent windows. We run them back-to-back to keep the project’s context warm. We resist mixing “research” with “drafting” in the same hour. We set a reversal: if we accidentally mix, we mark the moment and adjust tomorrow’s plan.

A note on judgment and emotion

We want to honor the small emotions in this practice. There is relief when we see a neat inbox after 30 minutes. There is frustration when a call loop keeps us on hold. There is curiosity when we notice a pattern in our avoidance (writing at 3 p.m. feels impossible). We let these register as signals, not verdicts. The practice is a place to train observation. Our log becomes more valuable than our story about willpower.

Combining batching with rest

We place short rests between batches (2–5 minutes). We stand, drink water, glance out a window. The pause prevents cognitive smearing between modes. We can log the rest if it helps us respect it. Without rests, we risk dulling each batch’s edge.

Mistakes we will make, and their fixes

• Starting a batch without a timer. Fix: Brali’s batch template can auto-start a timer; enable it.
• Forgetting the script. Fix: put the script at the top of the batch list as the first item. Check it off as a ritual.
• Overfilling. Fix: cap items to what fits in the time block. Extra items get a “next batch” tag.
• Neglecting review. Fix: end each batch with a 30-second note: “One thing that pulled, one thing that helped.” It trains the next round.

Metrics that matter

Two numbers drive adherence:

1. Batches completed per day (count). Aiming for 2–4 is realistic for most knowledge workers.
2. Unplanned context switches (count). Aiming for ≤10 during work hours is a crisp target that invites small wins.

Optional numbers:

• Minutes in batch (total).
• Messages cleared (count).
• Response time percentiles if our role demands tracking.

We do not drown in numbers. We choose one or two and let them guide us.

Integrating with Brali LifeOS

We open the Brali LifeOS “Batch Similar Tasks Planner.” We create four templates: Messages, Calls, Admin, Writing. We attach scripts and timeboxes. We add a daily check-in that asks about physical and cognitive sensations (“itch to switch: 1–10,” “clarity after batch: 1–10”), and a weekly one that asks about consistency and outcomes. We turn on the “Batch Gate” to hide not-in-batch tasks. This is not a gadget show; it is a set of switches that simplify the decision, “Now we do this, not everything.”

Mini-App Nudge: Add the “Switch Counter” micro-module to your batch view in Brali. Each time you resist a pull, tap +1. The tiny dopamine hit helps, and the trendline tells the truth.

Case: batching at home

A Saturday morning. We have laundry, dishes, meal planning, and home admin (insurance form). If we let the day “flow,” we will half-do each and feel fuzzy by noon. We choose two batches: Housework (laundry, dishes, counters) for 45 minutes; Home Admin (form, renew library books, schedule vet) for 25 minutes. We set the timer, put on a playlist, and run. We stack laundry first (wash cycle 35 minutes), then dishes and counters while the machine runs. We avoid the phone. The form is annoying; we time-box and leave a sticky note with the missing info. By 11:00, two buckets are empty. The rest of the day can be looser, because the important dull things are done.

Fitting batching to energy

We can tie categories to energy curves. If our attention peaks 90 minutes after waking, we put Writing there. If we slump after lunch, Admin gets that slot. If we get a social energy spike mid-afternoon, Calls live there. We do not need perfect data; a week of notes will show patterns. We annotate inside Brali: “Energy 7/10,” “Energy 3/10.” We keep that column in view.

When life piles up

Some weeks bring clusters: tax season (Admin explodes), event planning (Calls spike), launch week (Messages surge). We respond with a heavier batch of the spiking category and lighter or fewer other categories. We write a “seasonal mode” into Brali with one tap. After the season, we return to the standard pattern. This expansion and contraction keeps us flexible.

Closing the loop each day

At day’s end, we run a 3-minute review.

• Which batches did we run?
• What completion criteria did we meet?
• How many unplanned switches?
• One sentence we would tell tomorrow’s self.

We write it in the Brali journal. The note is small. It remembers for us.

Practice notes from the field

We noticed that when we name batches with verbs (“Clear Messages,” “Run Admin”), we feel more like moving. When we name them with nouns (“Email,” “Admin”), we drift. We renamed and saw a modest lift in start rate (from 70% to 82% over two weeks). It is small and real.

We learned that batch length affects quality curves. Messages have diminishing returns after 45 minutes; we get sloppy. Admin gets dangerous after 60 minutes; we start clicking without reading. Writing improves for 25–45 minutes, then holds steady until 90 if we rest at minute 45. We adapted our default durations accordingly.

We assumed more batches meant more productivity. We observed that more than four per day made us brittle and reactive. We changed to a maximum of four, preferring three, with a micro-sweep if needed.

We found that pairing batches with a consistent start ritual matters: one breath, one sip of water, one glance at the script. It sounds quaint; it works.

The smallest useful success

If we are overwhelmed, we choose one batch of 10 minutes and one measurable outcome (“reply to 5 messages” or “file 3 receipts”). We set a timer, press start, and stop at the bell. We log it. We tell ourselves we are the kind of person who runs small, focused units. We are.

Common objections and our replies

• “My tasks are too varied.” Then our categories are too broad. Split by mode: scanning vs. deciding vs. speaking vs. form-filling. We can always find a pair.

• “I tried batching and fell behind.” Likely we hid work in Writing or Decision tasks during a Messages block. We assign them properly and shrink message blocks. We add a midday sweep. We monitor response times.

• “I like being available.” Availability is valuable, but it is not the same as effectiveness. We can design windows of high availability around batches. The consistency gives colleagues more, not less, of what they need.

• “I have to be creative when the muse hits.” We respect the muse and also notice that it visits more often when invited at a regular hour. The block’s function is not to extract; it is to make space.

Weekly review

Once a week, we view our Brali chart. We tally batches per day, unplanned switches, and one qualitative note. We notice that Tuesdays had the highest switch counts due to a recurring meeting. We move the writing block to Wednesday mornings. We send one email to the team proposing a 30-minute quiet window on Tuesday afternoons. We test for a week and review the effect.

The aim here is not to build a religion. It is to build a structure that favors finishing over dabbling.

We return to today. We look at our list. We pick Messages and Admin. We give them shapes. We run one. That is enough for now.

Check‑in Block (Brali LifeOS or paper)

• Daily (3 Qs):

  1. How many batches did we complete today? [count]
  2. How many unplanned context switches did we notice? [count]
  3. After the last batch, what sensation was strongest: clearer head, relief, or fatigue? [choose one; 1–2 words]

• Weekly (3 Qs):

  1. On how many days did we complete at least 2 batches? [0–7]
  2. Which category consistently slipped (Messages, Calls, Admin, Writing), and what one change will we test next week?
  3. Did average response times stay within our target? [yes/no + note]

• Metrics:

  • Batches completed (count per day)
  • Unplanned context switches (count per day)

Busy-day alternative path (≤5 minutes)

• Open Batch: Messages.
• Set a 5-minute timer.
• Answer the shortest replies first (5–7 items). Archive. Stop at the bell. Log “1 micro-batch.”

A last small scene

We are at the kitchen table at 16:02 with a cup of tea. The Admin batch is open. The timer shows 24:58. We rename the last PDF and feel the quiet land. There is no rush to the next window because the next window is not open. We let the feeling register: we did one thing the whole time. It is not heroic. It is human-sized. It works because it respects the way our mind starts slow, warms up, and then prefers to stay in its lane.

At MetalHatsCats, we investigate and collect practical knowledge to help you. We share it for free, we educate, and we provide tools to apply it. If we adopt batching as a gentle rule, we claim back scattered minutes and convert them into minutes we can remember.

—