Six Core Patterns of Claude Code Dynamic Workflows Explained by an Engineer

Claude Code originally combines planning and execution in a single context window, which works for short tasks but leads to three problems for longer tasks: Agentic laziness (premature completion), Self‑preferential bias (the AI over‑trusts its own output), and Goal drift (constraints disappear after context compression).

Dynamic workflows address these issues by having Claude generate a JavaScript scheduler that spawns independent sub‑agents, each with its own context window and explicit goal. This decouples planning from execution and prevents the three failure modes.

The core API consists of two functions: agent(prompt, opts?) – accepts a prompt and optional parameters (model, isolation, output schema, agent type) and returns a Promise whose result can be a string or JSON‑schema data. Example:

await agent("audit auth.ts", {
  schema: BugList,
  model: "haiku",
  isolation: "worktree",
  agentType: "reviewer"
});

parallel([fns])

– runs an array of functions in parallel, leveraging standard JavaScript JSON, Math, and Array utilities for data handling.

Compared with static workflows, which must anticipate every edge case and are therefore more generic, Claude Opus 4.8 can now write a custom scheduler that adapts precisely to a given task.

Six Common Dynamic‑Workflow Patterns

Classify‑and‑Act : Incoming tasks are first classified, then routed to specialized agents (e.g., reading code, implementing changes, adding tests) instead of relying on manual judgment.

Fan‑out‑and‑Synthesize : A large task is broken into many small steps, each executed by an independent agent. A barrier step waits for all agents to finish before synthesizing a structured result.

Adversarial Verification : The output of one sub‑agent is checked by a separate, independent agent, providing a more reliable validation than self‑checking.

Generate‑and‑Filter : A batch of candidates is generated first, then filtered and deduplicated according to defined criteria, useful for naming, drafting designs, or creating test cases.

Tournament : Multiple agents solve the same problem with different approaches; pairwise comparisons determine the winner, offering more robust judgments than absolute scoring.

Loop‑until‑Done : For tasks with unknown workload, agents are repeatedly spawned until a stop condition—such as no new findings or no new errors—is met; clear stop criteria prevent endless generation.

Illustrative Use Cases

Migration and Refactor : The Bun‑to‑Rust rewrite was orchestrated with a workflow that split the migration into steps (call points, failure tests, modules). Each fix ran in an isolated worktree, was reviewed by an adversarial agent, and then merged.

Deep Research : Claude’s built‑in /deep‑research skill uses dynamic workflow to distribute searches, fetch sources, perform adversarial verification, and compile a report.

Deep Verification : To audit a factual report, a workflow first extracts all factual statements, then spawns agents to verify each claim, and finally a verification agent checks source quality.

Sorting Large Datasets : Sorting 1,000 lines in a single prompt degrades quality. Using the Tournament pattern, pairs of agents compare subsets, or parallel bucketing followed by merging preserves accuracy.

Root‑Cause Investigation : Multiple independent hypotheses are generated by separate agents and each is validated by dedicated verifier agents, a method applicable to sales analysis, data‑pipeline debugging, and post‑mortems.

Memory and Rule Compliance : When Claude repeatedly misses rules, a workflow assigns each rule to a verification agent and adds a skeptic agent to audit the rule set, preventing false positives.

Large‑Scale Classification : Support queues or bug reports can be automatically classified, deduplicated, and acted upon; untrusted content is handled by a low‑privilege agent, while privileged actions are performed by a separate executor agent, optionally combined with a /loop for continuous operation.

Exploration and Taste : Agents generate a batch of design or naming options, a reviewer agent scores them, and the workflow stops when the reviewer deems a candidate satisfactory; tournament ranking can further order the options.

Lightweight Evaluation : Independent agents execute a skill in a worktree, then a comparison agent scores the result, enabling quick assessment and optimization of custom skills.

Model Routing : A classification agent assesses task complexity and routes the request to an appropriate model (e.g., Sonnet for simple explanations, Opus for deep analysis).

When Not to Use Dynamic Workflows

Dynamic workflows consume more tokens. For routine coding tasks that do not require a five‑agent review panel, the extra cost may outweigh benefits. Ask whether the task truly needs additional compute.

Practical Tips

Craft detailed prompts that reference the specific patterns you want to invoke.

Use the "quick workflow" shortcut for rapid adversarial verification.

Make reusable workflows (e.g., triage, research) persistent with /loop and /goal directives.

Set a token budget, such as "use 10k tokens", to control cost.

Save workflows to ~/.claude/workflows or distribute them via a skill package.

When sharing a skill, place the JavaScript workflow file in the skill folder and reference it in SKILL.MD as a template rather than a literal script.