The Delegation Reflex | Bristena Oprisanu

I caught myself mid-keystroke last week. Fingers on the keyboard, about to trace my way through a codebase I barely knew.

Then I stopped. Opened a different window. Fired off three explore agents in parallel.

Went to make coffee.

By the time I got back, I had answers from three different angles. File paths. Pattern matches. Context I would've spent 20 minutes piecing together.

This is the reflex I've been training.

The Old Pattern

My instinct, built over years of solo coding: see problem, start solving.

Need to understand how auth works? Start reading files. Need to find where errors are handled? Grep around. Need to check if a pattern exists elsewhere? Open a few tabs.

It works. It's slow. And with AI agents available, it's now a bad habit.

The problem isn't that I can't do the work. It's that doing it myself has an opportunity cost. While I'm reading files, I'm not thinking about the actual problem.

The New Pattern

Now, before I touch the keyboard, I ask: who should do this?

Not "can I do this?" — of course I can. The question is whether I should.

If the task is:

Exploration (finding patterns, understanding structure) → Fire an explore agent
External knowledge (library docs, API examples) → Fire a librarian agent
Hard reasoning (architecture, debugging after failures) → Consult oracle agent
Trivial (one file, known location) → Do it myself

The decision takes two seconds. Getting it wrong costs minutes or hours.

Parallel First, Sequential Never

Here's the real unlock. It's not just delegation—it's parallel delegation.

Old pattern:

Ask question → Wait → Read answer → Ask follow-up → Wait → Read answer

New pattern:

Fire 5 agents with different angles → Work on something else → Collect results

When I'm exploring unfamiliar code, I don't ask one question. I ask five:

Where's the auth middleware?
How are errors handled in this layer?
What patterns exist for validation?
Where's the database schema?
How do tests structure this?

Five agents. Five parallel searches. I get back a composite picture, not a single thread.

Why Sequential Thinking Is a Bottleneck

Think about how you'd explore a new codebase manually:

Search for auth → find 3 files → read them
Based on what you learned, search for error handling → find 2 files → read them
Notice a pattern, search for validation → find 4 files → read them

Each step waits for the previous. Total time: 45 minutes of sequential discovery.

Now imagine:

Fire 5 agents simultaneously, each searching a different aspect
Work on your actual task (or make coffee)
In 3 minutes, collect all results

Same information. Fraction of the time. And you weren't blocked waiting.

The sequential habit is so ingrained that it feels weird to ask five questions at once. "What if the third question depends on the first answer?" Usually it doesn't. And when it does, you can fire a follow-up.

The Coffee Test

Here's my heuristic: if I can make coffee while agents work, I'm doing it right.

Fire agents → start coffee → return to results.

If I'm sitting there watching agents think, I've failed. The whole point is that my attention is freed up.

This sounds trivial. It changed how I work. The mental shift from "I'm waiting for an answer" to "answers are cooking while I do something else" is surprisingly powerful.

The Uncomfortable Part

There's a feeling I had to push through: not being the one typing.

Developers are rewarded for doing. Lines of code. Files changed. Commits pushed. There's something uncomfortable about sitting back while agents work.

It feels lazy. It feels like cheating.

It's neither. It's leverage.

The work still gets done. The thinking is still mine. I'm just not the one grepping through directories.

When Delegation Is Overhead

Not everything should be delegated. The reflex can overcorrect.

Delegation is overhead when:

You know exactly what file to read (just read it)
The task is a single command (just run it)
Context switching would cost more than doing it

The heuristic I use: if I can do it in under 5 minutes, do it myself.

Anything longer, and the delegation cost is worth it.

Building the Reflex

Reflexes are trained, not decided. Here's what built mine:

1. Make delegation easier than doing

If firing an agent requires thinking about syntax, I won't do it. The command needs to be instant. For me, it's muscle memory now — the delegation pattern is faster to type than the grep pattern.

2. Default to parallel

When I catch myself about to fire one agent, I pause and ask: "What else could I ask at the same time?" Usually there are 2-3 related questions I'd ask sequentially anyway. Fire them all now.

3. Celebrate the saves

Every time delegation saves significant time, I notice it. Not formally — just a moment of "that would've taken 15 minutes." Reinforcement.

4. Catch the instinct

The hardest part: noticing when I'm about to start work I should delegate. Mid-keystroke awareness. It's awkward at first. It becomes natural.

What Changed

My workflow now has a shape:

Understand the task (thinking, not typing)
Delegate exploration (fire agents for context — plural, parallel)
Work on what only I can do (design, decisions, tricky logic)
Collect results (agents return, I synthesize)
Execute (now I type, with full context)

The typing happens later. And when it happens, it's faster — because I'm not discovering context while I code.

The Meta-Lesson

The delegation reflex isn't about AI. It's about recognizing that not all work is equal.

Some work is thinking. Some work is typing. Some work is waiting for a computer to search.

I should be doing the thinking. The computer should be doing the searching. And it should be doing five searches at once, not one at a time.

It took me longer than I'd like to admit to internalize this. But now, mid-keystroke, I catch myself.

And I delegate. In parallel.

What's your delegation heuristic? I'd love to hear what triggers you to hand off work vs. do it yourself.