Async Workflows

Interactive vs fire-and-forget. When each one wins, and how to combine them.

Everything so far has been interactive: you type, Claude responds, you review, you iterate. But there is another mode of working with AI that becomes useful once you are comfortable with the basics.

Two Modes of Working with AI

There are fundamentally two ways to use AI for tasks:

• Interactive (supervised): You are in the loop. You watch what AI does, correct it in real time, review each step. This is what Claude Code does by default. Good for exploration, complex tasks, and anything that requires judgment.
• Async (fire-and-forget): You describe a task, hand it off, and come back later to check the result. AI works on its own without your supervision. Good for well-defined, bounded tasks where you can verify the output after the fact.

Most of your work will be interactive, especially early on. Async becomes valuable once you have tasks that are clearly specified and easy to verify.

When Interactive Wins

Use interactive mode (Claude Code conversations) when:

• You are exploring data and do not know exactly what you want yet
• The task requires domain knowledge mid-process (choosing a specification, interpreting results)
• The output is hard to verify after the fact (you need to see it being built)
• You are iterating: plan, review, correct, repeat
• The task touches multiple files or has complex dependencies

In practice, this covers most research work. Data cleaning, regression analysis, writing code, debugging, and any task where your judgment shapes the output.

When Async Wins

Async mode shines when:

• The task is well-defined with clear inputs and outputs
• You can verify the result by inspection (checking a file, reading output, running a test)
• The task is bounded (it should not require judgment calls mid-process)
• You have multiple independent tasks that could run in parallel

Examples from research work:

• Formatting 20 tables to match a journal's style guide
• Converting a batch of do-files from Stata 14 to Stata 18 syntax
• Adding standardized headers and comments to all scripts in a project
• Running the same cleaning pipeline on multiple datasets

A Decision Framework

When deciding which mode to use, ask three questions:

1. Can I specify this task completely in advance? If yes, async might work. If you need to make decisions along the way, stay interactive.
2. Can I verify the result after the fact? If the output is a file you can check, async works. If verification requires understanding the process (not just the result), stay interactive.
3. Is the task reversible? If something goes wrong, can you undo it? If yes, async is safe to try. If the task modifies irreplaceable data, stay interactive.

Combining Both Modes

The most effective workflow often combines both:

1. Interactive: Use Claude Code to plan the task, review the approach, and verify it on a small sample.
2. Async: Once the approach is verified, hand off the full batch to run without supervision.
3. Interactive: Review the results, spot-check, and iterate if needed.

This is the pattern for most batch operations. You would not send 50 tables to be reformatted without first testing the formatting on one table interactively. Once it works, you batch the rest.

Current Tools

Claude Code is primarily interactive. You can give it longer-running tasks, but you are still in the conversation, watching it work.

Codex (OpenAI) is the main async coding agent available today. You describe a task, it works on it independently, and you review the result later. It is best suited for the bounded, well-specified tasks described above.

Claude Code with background agents also supports fire-and-forget patterns for bounded tasks. The tool you use matters less than the framework: can you specify it clearly, can you verify the result, and is it reversible?

For large-data pipelines that combine both modes (interactive planning, async batch processing), see the Large Datasets page.