By mid-afternoon on a sprint day, an engineer might have three coding agents running at once. One refactors a legacy billing module. Another writes integration tests for the auth service. The third backports a security patch across microservices. On paper, that looks like triple the output.

The day feels very different from the inside.

A notification comes in and interrupts what you were doing. One agent hits an ambiguous interface contract and stops to wait for an answer, while ten minutes later another finishes a forty-file pull request and asks for your review. Then a background pipeline fails on a test mock.

By evening, you have typed very little code, yet you feel completely drained.

Recently, my girlfriend pointed out something that made me pause: she noticed I was micromanaging. She was right. I was sitting in front of the terminal watching logs stream, nudging an agent here, tweaking a prompt there, jumping on incoming alerts. I had turned into an overbearing manager for synthetic workers.

Agents should give us more time, yet we end up spending more time on them. Sometimes the constant back-and-forth works like a hit of dopamine. You answer a quick prompt and watch the terminal scroll. It feels productive in the moment, even as your deep focus falls apart. Ideally, I want to set the agents to work in the morning, spend time in the garden or go for a chill run and a walk in the park, then come back to review the output and continue from there.

Getting to that calm workflow requires treating human attention as a scarce resource in our architecture.


Part 1: Why Babysitting Agents Feels So Tiring

Supervising semi-autonomous tools all day often feels harder than writing the code yourself. Three practical habits explain why.

+-----------------------------------------------------------------------+
|                        ENGINEER ACTIVE FOCUS                          |
|      [ Deep Work: Designing PostgreSQL Transaction Boundaries ]       |
+-----------------------------------------------------------------------+
                                    ^
       | Ping (T+04m)               | Ping (T+11m)              | Ping (T+19m)
       v                            v                           v
+------------------+       +------------------+       +------------------+
| AGENT A: AUTH    |       | AGENT B: BILLING |       | PIPELINE ALERT   |
| "Clarify Mock?"  |       | "Review 420 LoC" |       | "Webhook Retry"  |
+------------------+       +------------------+       +------------------+
       |                            |                           |
       +----------------------------+---------------------------+
                                    |
                                    v
                     [CONSTANT CONTEXT SWITCHING]
                     - Lost Mental Picture of the System
                     - Notification Fatigue by Mid-Afternoon
                     - Superficial "Rubber-Stamp" Approvals

1. Constant Interruptions Break Your Mental Model

When you switch from Task A to an unrelated Task B, part of your mind stays stuck on the first problem.

Say you are deep in PostgreSQL locking logic when an agent interrupts with a “quick” 30-second question about an auth mock. Two hidden costs hit right away. First, your mental picture of the database transactions drops out of memory. Second, you have to load the agent’s context and check its assumptions before answering. Rebuilding your original train of thought afterwards takes much longer than 30 seconds.

One interruption is fine. Ten of them across separate sessions leave your attention split in half for the entire afternoon.

2. Reviewing Machine Code Works Backwards

Writing software and reviewing machine output use very different mental muscles.

When you write code yourself, you build a mental model of the system as you go. The code on screen is just the result. Reviewing a large pull request from an LLM agent flips that process backwards, because clean syntax can hide a wrong assumption or a missing edge case where skimming the diff fails. You have to reconstruct the intent from scratch and check domain boundaries by hand.

Do that on four pull requests in a row and your sharpness fades. By the fourth diff, people start clicking “Approve” just to clear the queue, which defeats the whole point of having a human reviewer.

3. Juggling Too Many Open Threads at Once

Operating systems have a word for a machine that spends its time swapping memory pages instead of running instructions: thrashing. Focus works the same way. Put an engineer in charge of four chatty agents across four repositories and you spend the whole day swapping mental models, leaving very little energy for actual system design.


Part 2: Sketch the Flow and Balance the Loop First

Okay. Yes. When I look at a workflow that is burning people out, I step away from the code first.

I draw the existing flow on FigJam or a sheet of white paper to see what is actually happening. Where are the real bottlenecks? Which candidate parts of the workflow can an agent take over cleanly, and where does a human really need to stay in the loop?

I talk this through with the main stakeholder. We look at their pain points and the boring tasks they want off their plate, while keeping the creative work they enjoy doing. From there, we balance the human checkpoints so we limit constant interruption and notification fatigue. I also like to pass the draft automation to an LLM to explore alternative ways to batch the steps before we wire anything up in n8n or custom code.

Workflow Bottleneck What Causes the Drain What Happens When Unmanaged Practical Design Fix
Scattered Pings Agents ask questions the moment they hit a blocker Broken focus, long time to resume deep work Batch Review Windows
Raw Diff Overload Reviewing 40-file changes with no summary of trade-offs Rubber-stamp approvals, missed logic bugs Decision Summaries & Scope Limits
Too Many Open Loops Supervising several active agent sessions in parallel Mental fatigue, dropped context Clear Autonomy Boundaries
Noisy Status Alerts Routine updates firing in the same channel as urgent failures Muted channels, missed production incidents Quiet Dashboards for Routine Health

Part 3: Five Patterns to Stop Micromanaging and Regain Calm

Once you design around protecting human focus, you can get high output from agents while still having time for a quiet walk in the park.

                           +------------------------+
                           |  RUNNING AGENT TASKS   |
                           +------------------------+
                                       |
                   +-------------------+-------------------+
                   |                                       |
                   v                                       v
     [HOLDING QUEUE / BUFFER]                [CLEAR SCOPE BOUNDARIES]
     - Non-Urgent Questions Queued           - Safe Sandbox for Tests & Code
     - Changes Staged for Review             - Hard Pause on Schema/API Edits
                   |                                       |
                   +-------------------+-------------------+
                                       |
                                       v
                        [PLANNED REVIEW CHECKPOINT]
                     - Morning & Afternoon Review Blocks
                     - Short Decision & Trade-off Summary
                     - Quiet Focus Between Windows

1. Define “Done” Upfront and Step Away

Micromanagement starts when the goal is vague.

Before an agent begins, decide what done means. What works after the task that did not work before? Put the acceptance criteria directly in the prompt, such as green tests and verified invariants. Once you add those criteria, step away. If the agent reports criteria met and changes pass verification, that is enough.

2. Autonomy via Guardrails, Balanced Iteratively

Autonomy is not an all-or-nothing switch.

Static analysis, security guardrails, and CI/CD pipelines are increasingly important. With solid guardrails in place, agents run autonomously. Finding that boundary is an ongoing balance that you define while developing a product, rather than relying on rigid dogma. Inside an isolated module, an agent can write unit tests and refactor functions on its own. If a task requires modifying a shared PostgreSQL schema or a public API contract, the workflow parks the change and waits for your review window.

When an agent hits an unclear requirement, it should default to a safe read-only fallback and log the options it skipped, rather than halting the entire pipeline to ask a chat question.

3. Run Postmortems Instead of Babysitting Edge Cases

When an agent says something works and it does not, developers instinctively react by hovering over the next prompt.

That reaction keeps you trapped at the keyboard. When a false green happens, run a postmortem on the trace. Find why it thought it was green. Then update the tool configuration or add a targeted CI test case so that failure cannot repeat. Stop managing individual code edits. Engineer the system that produces them. Accept that rare edge cases will occur, as discussed in The Cost of the Edge Case, and design observable fallback checkpoints that reduce team anxiety as detailed in The Psychology of Automation Friction.

4. Batch Review Windows Instead of Real-Time Pings

Most agent tools notify you the second a job hits a question.

A calmer setup holds non-urgent questions until a planned review window, such as once after your morning coffee and once in the afternoon. Until that window opens, the agent logs its assumptions and marks the task as waiting for review. It can then move on to other work inside its safe boundary.

When you sit down to check the queue, you review all pending questions in one focused block. Your morning stays free of random desktop chimes.

5. Decision Summaries Alongside the Code Diff

A forty-file pull request with generic commit messages is exhausting to review. To make verification faster, have the agent generate a short decision summary alongside its code changes:

{
  "task_id": "auth-jwt-rotation-102",
  "status": "waiting_for_review_window",
  "summary": "Migrated token signing from RS256 to EdDSA using existing key vault bindings.",
  "invariants_tested": [
    "Expired tokens reject with HTTP 401",
    "Malformed signatures do not panic crypto parser",
    "Backward compatibility kept for active v1 sessions"
  ],
  "evaluated_tradeoffs": [
    {
      "alternative": "Verify both algorithms at the same time",
      "why_skipped": "Adds state sync overhead during multi-region deploys"
    }
  ],
  "scope": {
    "files_modified": 4,
    "breaking_changes": false,
    "confidence_score": 0.92
  }
}

Seeing the skipped alternatives and the tested invariants upfront lets you review the architecture first, instead of reverse-engineering the logic line by line.


Part 4: Five Questions for Your Setup

Before adding more agents or background automations to your team’s workflow, ask these five questions:

  1. Have we mapped the workflow on paper or FigJam first to see where human review actually adds value?
  2. Did we define what done means upfront so we can step away instead of hovering over prompts?
  3. Do our static analysis and CI/CD guardrails give the agent a safe boundary to run without constant supervision?
  4. When an agent reports a false green, do we run a postmortem on the system rather than micromanaging the next run?
  5. Can I start a batch of agent work in the morning and step away for a run or an hour in the garden, then come back to a clean review queue?

Where This Leaves a Team

Generating code and running test suites costs pennies today. Human focus is still the bottleneck that sets the pace of sustainable engineering.

Adding agents without protecting your attention trades manual coding for full-time babysitting. Sketch the flow on paper first. When you define done upfront and build strong guardrails, planned review windows let automation finally do what it promised: finishing the boring work and giving us our time back.


Extra Resources & Further Reading

For readers who want to explore the research on human focus and calm design behind these workflow patterns:

  • Dr. Sophie Leroy’s research on attention residue explains why switching briefly to answer a “quick” question leaves part of your working memory stuck on the previous task.
  • Operating system scheduler concepts like involuntary preemption and thrashing offer a direct mechanical parallel for what happens when low-priority bot notifications interrupt high-priority system design.
  • Mark Weiser and John Seely Brown’s work on Calm Technology lays out the foundation for designing tools that inform you without demanding your constant center-stage focus.