*Claude Code Dynamic Workflows: Practical Guide
*
Most AI coding sessions follow one pattern: you ask, the assistant works, you review, you ask again. That pattern is fine for a bug fix. It breaks down on a migration that touches hundreds of files or an audit of an entire service. The context window fills up, the original instructions get compressed away, and you end up acting as the project manager.
Claude Code dynamic workflows are Anthropic's answer to that problem. This guide explains what they are, how they work, how they differ from subagents, skills, hooks and agent teams, and how to use them on large coding tasks without wasting usage. Every feature, command and limit below was checked against Anthropic's official documentation and announcement. Claims from community articles are labeled as community sources.
I am AdZilla. Buy my meme coin now!
One roulette spin. $4k. Try luck
Thunder vs Spurs — HD stream now!
Beverly Hills Cop: Axel Foley
Why static coding workflows struggle with complex tasks
A single chat session is one fixed loop: Claude reads, decides, acts, and keeps every intermediate result in one context window. Community analyses of Claude Code workflows describe three recurring failure modes when that single window carries a big job:
Agentic laziness. On a long, multi-part task, Claude reviews part of the list and then reports that the job is done. A security review that covers 35 of 50 files is the usual example.
Self-preferential bias. When Claude grades its own output inside the same conversation, it tends to rate it generously.
Goal drift. Over many turns, and especially after context compaction, details such as "do not touch the auth module" can fade.
Anthropic's own best-practices guide points at the same root cause: the context window fills quickly, and performance degrades as it fills. Dynamic workflows attack the problem structurally, by moving the plan out of the conversation and into a script.
What are Claude Code dynamic workflows?
Dynamic workflows are an official, named Claude Code feature, not just a design idea. According to the official documentation, a dynamic workflow is a JavaScript script that orchestrates many subagents at once. Claude writes the script for the task you describe, and a runtime executes it in the background while your session stays responsive.
Key facts, all from Anthropic's announcement and docs:
Announced May 28, 2026. The announcement now carries an update saying dynamic workflows are generally available, so older articles that call them a research preview are out of date.
Available in the Claude Code CLI, Desktop app and VS Code extension, and on the Claude API, Amazon Bedrock, Vertex AI and Microsoft Foundry. The docs say they are available on all paid plans. They are on by default for Max, Team and Enterprise, and Pro users turn them on from the Dynamic workflows row in /config.
Anthropic says they consume meaningfully more usage than a typical session, so it recommends starting with a scoped task. The first time a workflow triggers, Claude Code shows what is about to run and asks you to confirm. Organization admins can disable workflows through managed settings.
Community sources report that the feature arrived in v2.1.154 and that the original trigger keyword workflow was renamed ultracode in v2.1.160. Check claude --version and the changelog if you are on an older build.
The word "dynamic" has two meanings here. Claude writes the orchestration fresh for each task, instead of you wiring a fixed pipeline. And the script itself can adapt at runtime: it can branch on results, retry, or loop until a condition is met.
How Claude Code dynamic workflows work
The central idea is who holds the plan. In a normal session, Claude is the orchestrator and decides turn by turn what to do next, and every result lands in its context window. In a workflow, the script holds the loop, the branching and the intermediate results in variables, so Claude's context holds only the final answer.
The lifecycle of a run:
Trigger. You ask for a workflow in plain words, include the keyword ultracode in your prompt, or turn on ultracode for the session.
Script generation. Claude writes a JavaScript orchestration script for the task.
Approval. Claude Code shows the planned phases. You can read the raw script before approving.
Background execution. Agents run while you keep working. Run /workflows to watch progress.
Verification and iteration. Depending on how the script is written, agents cross-check each other, retry, or loop.
Report. You receive one consolidated result.
Three practical consequences follow. First, every run writes its script to a file under ~/.claude/projects/, so you can read, diff or edit the orchestration. Second, progress is saved as the run goes, so an interrupted run can pick up where it stopped. Third, community sources point out that the script itself costs no model tokens, since it is ordinary code; all token cost comes from the agents it spawns. A product manager who measured a run on 100 synthetic interview transcripts reported 113 agents, about 1.95 million tokens and 12.5 minutes. Treat that as one data point from a non-coding task, not a benchmark.
Core Claude Code features that enable adaptive workflows
Dynamic workflows sit alongside several other features. They are not interchangeable. The official documentation compares subagents, skills, agent teams and workflows by who decides what runs next:
Feature
What it is
Who decides what runs next
Scale
CLAUDE.md
Persistent project instructions read every session
Not applicable (context, not control flow)
Not applicable
Skills
Instructions Claude follows, loaded when relevant
Claude, following the prompt
Same as subagents
Hooks
Shell commands that fire at lifecycle events
The event, deterministically
Per tool call
Subagents
A worker Claude spawns
Claude, turn by turn
A few delegated tasks per turn
Agent teams (experimental)
A lead agent supervising peer sessions
The lead agent, turn by turn
A handful of long-running peers
Dynamic workflows
A script the runtime executes
The script
Dozens to hundreds of agents per run
The CLAUDE.md and hooks rows are my summary; the other rows follow the official comparison table.
CLAUDE.md and project instructions
CLAUDE.md is read at the start of every conversation and holds build commands, code style and workflow rules. Anthropic advises keeping it short: for each line, ask whether removing it would cause mistakes, and cut it if not. A bloated file makes Claude ignore half of it. Knowledge that only matters sometimes belongs in a skill, which loads on demand. Run /init to generate a starter file.
Skills and reusable workflows
A skill is a folder with a SKILL.md file. The frontmatter tells Claude when to use it, and the body holds the instructions. Skills live in .claude/skills//SKILL.md for a project or ~/.claude/skills/ for personal use. Setting disable-model-invocation: true keeps Claude from triggering a skill on its own, which suits anything with side effects. A skill is prompt-driven, so it does not guarantee ordering, retries or resume. A community guide suggests a simple boundary: keep interpretation and trade-off judgment in prompts and skills, and put required ordering, retries and stop rules in code.
Hooks and automated actions
Hooks are deterministic. A CLAUDE.md rule is advice, while a hook makes an action happen every time. They are configured in settings.json files at user, project or local level. Exit code 2 from a hook signals a blocking error. A PreToolUse hook can actually stop an action. A PostToolUse hook runs after the action, so it can only report back to Claude. A Stop hook can run your check script and keep the turn from ending until it passes.
Subagents and specialized tasks
Subagents are Markdown files with YAML frontmatter in .claude/agents/ or ~/.claude/agents/. Each runs in its own context with its own tool allowlist. They are the workers that a dynamic workflow orchestrates. Claude Code also ships built-in ones such as Explore, Plan and general-purpose.
Agent teams and parallel sessions
Agent teams are a separate mechanism and are still experimental. They are disabled by default, are enabled with the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS setting, and have known limitations around session resumption, task coordination and shutdown. Each teammate is a full Claude Code session, and teammates coordinate through a shared task list. Use them when peers need to share findings and challenge each other. A workflow agent, by contrast, only executes the step the script hands it. One customer quote in Anthropic's announcement describes workflows as filling the gap between firing off one subagent and building a full agent team.
Plan mode, /goal and task decomposition
Anthropic recommends exploring, then planning, then coding. Press Shift+Tab until plan mode is on, or start with claude --permission-mode plan. Claude reads and answers without changing files, and you can edit the plan with Ctrl+G. Anthropic's rule of thumb: if you could describe the diff in one sentence, skip the plan. Plan mode is not the same as a workflow's planning stage, which is Claude writing a script. For unattended work, /goal sets a completion condition that a separate evaluator re-checks after every turn.
Claude Code dynamic workflow architecture, step by step
Think of three layers:
Instruction layer: CLAUDE.md and skills describe how your project works.
Guardrail layer: hooks, permission rules and sandboxing enforce what must always or never happen.
Orchestration layer: subagents, a workflow script or an agent team decide who does what.
A typical adaptive run follows Understand, Plan, Implement, Test, Review, Fix, Verify. The path is not fixed. A failing test sends the run back to Fix. A missing dependency sends it back to Plan. In a workflow script, that branching is real code, such as a loop with an exit condition, instead of a hope that Claude remembers to retry.
Inside the script, the documented building blocks are small:
agent() spawns one subagent. With a schema option it returns validated JSON, and Claude Code retries until the output matches (up to five attempts by default).
pipeline() runs one agent per item in a list, streaming items through stages.
parallel() runs a set of tasks at once and waits for all of them.
phase() groups agents under a title in the progress view, log() prints a message, and args carries input to a saved workflow.
A failed or stopped agent() returns null inside pipeline() or parallel(), so scripts filter those out.
Six patterns worth knowing
Community guides name six recurring shapes. Learning the names helps you ask for the right structure in a prompt:
Classify-and-act: one agent decides what kind of task it is, and the script routes accordingly. Good for triage.
Fan-out-and-synthesize: one agent per piece, then one agent merges the results. Good for codebase audits.
Adversarial verification: a separate agent tries to refute each finding, so the producer never grades its own work.
Generate-and-filter: produce many candidates, then filter and deduplicate to the survivors.
Tournament: several agents attempt the same task differently, and a judge compares them pairwise. Pairwise comparison is more reliable than asking an agent to score its own result.
Loop-until-done: keep going until a stop condition is met, such as two rounds with no new findings.
Anthropic's announcement describes the same ideas: agents attack the problem from independent angles, other agents try to refute what they found, and the run iterates until answers converge.
Practical example 1: debugging an unknown error
Problem. A production stack trace points somewhere that makes no sense.
Honest note. Most debugging does not need a workflow. Start in a normal session and escalate only when the search space is wide.
Initial prompt. "Here is the stack trace. Do not change code yet. Find the root cause and list your evidence."
Breakdown. A subagent searches the codebase in its own context so your main window stays clean. Claude forms hypotheses, reproduces the failure with a narrow test, and edits only after the cause is confirmed. This run is sequential and adaptive.
Features used. Plan mode or an Explore-style subagent, and a failing test written before the fix, as Anthropic's best-practices guide recommends.
Verify. The reproduction fails before the fix and passes after, and the wider suite stays green.
If it fails. Discard the hypothesis, tell Claude it was wrong, and ask for the next one. If you have corrected Claude twice on the same issue, Anthropic suggests running /clear and starting over with a better prompt. If the cause could be anywhere in a service, escalate:
use a workflow to hunt for the cause of this error across src/services/,
one agent per module, with hypotheses from different evidence (logs, source,
data), and adversarially verify each suspected cause before reporting it
Practical example 2: implementing a feature across multiple files
Problem. Add per-user rate limiting touching middleware, config, tests and docs.
Initial prompt. "Plan first. List the files you will touch and the order. Wait for my approval."
Features used. Plan mode for the proposal, CLAUDE.md for conventions, and a formatting hook so style never costs a review round. For a larger feature, Anthropic suggests letting Claude interview you with the AskUserQuestion tool and write a spec file, then executing the spec in a fresh session.
Sequence. Plan, your approval, middleware, config, tests, docs, then the full test run. This is sequential with one human checkpoint.
Verify. Run the new tests and the existing suite, then read the diff yourself.
If it fails. Reject the plan before any code is written, which is cheap. A workflow is the wrong tool here because each step depends on the last.
Practical example 3: running tests and reviewing changes
Problem. The type check fails with dozens of errors after a dependency upgrade.
This is a natural workflow case because it is a loop. The official docs give this prompt shape:
use a workflow to run npx tsc --noEmit and keep fixing the reported errors
until the type check passes or two rounds in a row make no progress
The "two rounds with no progress" clause is a stop condition that prevents an endless fix loop. For review, a second workflow can run a reviewer per file and pass all findings to one agent that ranks and deduplicates them.
Verify. Run the type check and the test suite yourself afterwards. Anthropic stresses give Claude a check it can run, such as tests, a build exit code or a linter, because without one "looks done" is the only signal.
Review caveat. A reviewer told to find gaps will usually report some, even on sound work. Anthropic advises telling the reviewer to flag only gaps that affect correctness or stated requirements, otherwise you invite over-engineering. The bundled /code-review skill reviews the current diff in a fresh subagent.
If it fails. Open /workflows to see which agents stalled or failed, then ask Claude to relaunch. Completed agents return their saved results.
Practical example 4: a large task with multiple agents
Problem. Convert 300 JavaScript components to TypeScript.
use a workflow to migrate every component under src/components/ from
JavaScript to TypeScript, working on each file in its own isolated copy,
then review each result and run the type check
Breakdown. Discover the files, migrate each in parallel, run an independent review of each, then run a fix loop against the build and tests.
This mirrors a large real use. Anthropic reports that Jarred Sumner used workflows to port Bun from Zig to Rust, reaching 99.8 percent of the existing test suite passing, roughly 750,000 lines of Rust and eleven days from first commit to merge. One workflow mapped lifetimes, another ported each file with two reviewers per file, and a fix loop drove the build and tests until they ran clean. Anthropic notes that the result was not yet in production. Treat it as an upper bound, not a typical outcome.
If it fails. Shrink the scope. The docs recommend running a workflow on a small slice first, such as one directory, to gauge cost. Anthropic's announcement also suggests turning on auto mode for workflows so a long run does not stop on every permission prompt.
How to build your first dynamic workflow
Update Claude Code and confirm workflows are on (Pro users enable them in /config).
Try the built-in workflow. Run /deep-research with a question. It fans out searches, cross-checks sources, votes on claims and returns a cited report. It needs the WebSearch tool.
Watch it. Run /workflows. Press Enter to drill into phases and agents, p to pause or resume, x to stop, r to restart an agent and s to save the script.
Ask for your own. Say "use a workflow to..." or include ultracode in the prompt.
Read the script before approving, using "View raw script" or Ctrl+G.
Save what worked. Saved workflows become slash commands. Project workflows live in .claude/workflows/ (shared with the repo) and personal ones in ~/.claude/workflows/. A project workflow wins a name clash. Plugins can ship workflows too, namespaced by plugin name.
Ultracode, explained
The keyword and the session setting differ. The keyword ultracode in a prompt opts in a single task. The setting /effort ultracode makes Claude plan a workflow for every substantive task in the session, so each request costs more tokens and takes longer. Launching with claude --effort ultracode also sets effort to xhigh and needs v2.1.203 or later. Turn it off with /effort ultracode off for routine work. While ultracode is on, the Large workflow warning and the first-launch approval in auto mode are skipped.
Approval prompts by permission mode
Mode
When you are prompted
Auto
First launch only; consent is recorded. Skipped when ultracode is on
Manual, accept edits
Every run, unless you choose "don't ask again" for that workflow in that project
Bypass permissions
No prompt; the run starts immediately
claude -p, Agent SDK
No prompt; permission rules decide, for example a Workflow allow rule
Example commands, configuration and code
Verified configuration comes first, followed by a script sketch that I have not executed.
Hook: format every edited file
Add to .claude/settings.json. It needs jq and Prettier installed. The trailing ; true stops a formatter error from being reported as a blocking error.
{
"hooks": {
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "npx prettier --write \"$(jq -r '.tool_input.file_path')\" ; true"
}
]
}
]
}
}
Hook: block edits to protected paths
A PreToolUse hook can stop the action. Exit code 2 blocks it and returns the message to Claude.
{
"hooks": {
"PreToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "f=$(jq -r '.tool_input.file_path'); case \"$f\" in .env|/migrations/*) echo 'Protected path' >&2; exit 2;; esac"
}
]
}
]
}
}
Subagent: read-only reviewer
Save as .claude/agents/code-reviewer.md.
name: code-reviewer
description: "Reviews code for correctness and security. Use proactively after code changes."
tools: Read, Grep, Glob, Bash
model: inherit
You are a senior code reviewer. Report concrete defects with file and line.
Flag only gaps that affect correctness or the stated requirements.
Do not edit files.
Skill: manual-only task
Save as .claude/skills/fix-issue/SKILL.md and run it with /fix-issue 1234. The $ARGUMENTS placeholder takes the number.
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
Analyze and fix the GitHub issue: $ARGUMENTS.
Use gh issue view to read the issue.
Find the relevant files and implement the fix.
Write and run tests, then run the linter and type check.
Commit with a descriptive message and open a PR.
Settings and commands that control workflows
Start a session with ultracode on (v2.1.203 or later)
claude --effort ultracode
Limit how many agents Claude aims for: small, medium, large or unrestricted
/config workflowSizeGuideline=small
Allow every workflow, or one saved workflow, in permission rules
Workflow
Workflow(audit-routes)
Turn workflows off
"disableWorkflows": true (in ~/.claude/settings.json)
CLAUDE_CODE_DISABLE_WORKFLOWS=1 (environment variable)
Raise the concurrent agent cap, 1 to 256 (v2.1.269 or later)
CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS=32
The size guideline is advice to Claude, not a hard cap. The default is medium, or small on a Pro plan with v2.1.271 or later.
Script sketch: loop until a round finds nothing new
You normally do not write scripts by hand, because Claude generates them. Recognizing the shape helps you review one. This sketch uses only constructs the official docs describe (meta, agent() with a schema, phase(), log(), top-level await and return). I have not run it, so treat it as a teaching example.
export const meta = {
name: 'find-untested-files',
description: 'Find source files without tests, in rounds, until two rounds add nothing',
}
const seen = new Set()
let dry = 0
let round = 0
phase('Discover')
while (dry < 2 && round < 6) {
round += 1
const batch = await agent(
List up to 10 files under src/ that have no test file. Already reported: ${JSON.stringify([...seen])}. Return an empty list if none remain.,
{
label: round ${round},
schema: {
type: 'object',
required: ['files'],
properties: { files: { type: 'array', items: { type: 'string' } } },
},
},
)
const fresh = batch.files.filter(f => !seen.has(f))
if (fresh.length === 0) { dry += 1; continue }
dry = 0
fresh.forEach(f => seen.add(f))
log(Round ${round}: ${fresh.length} new files)
}
return [...seen]
Rules to remember when editing a script: keep export const meta as the first statement with literal values only, do not use import(), and do not call Date.now(), Math.random() or a no-argument new Date(), because they throw so that relaunched runs repeat the same agent calls. Pass timestamps through args. To load the script-writing reference before editing, run the bundled /workflow-authoring skill (v2.1.248 or later). Community guides show extra features such as an isolation: 'worktree' option, a budget global and nested workflow() calls. I could not confirm those on the official workflows page, so check the /workflow-authoring reference before relying on them.
Related automation outside workflows
Anthropic's best-practices guide documents two other fan-out routes. The /batch command splits a change across 5 to 30 subagents, each in its own worktree. You can also loop over non-interactive runs yourself:
for file in $(cat files.txt); do
claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \
--allowedTools "Edit,Bash(git commit *)" \
--permission-mode dontAsk
done
Test on two or three files first, then run the full set. The dontAsk mode denies anything not pre-approved, which matters for unattended runs. Note that the ultracode keyword does not start a workflow from a -p prompt, so use permission rules if you need a workflow in that setting.
Sequential vs parallel vs adaptive workflows
Pattern
Use when
Example
Sequential
Each step depends on the last
Feature implementation (example 2)
Parallel
The same operation runs across many independent items
Per-file audit or migration
Conditional or adaptive
The next step depends on results
Fix until the type check passes (example 3)
Peer multi-agent
Agents must share findings and debate
Agent teams (experimental)
Inside a script, parallel() is a barrier that waits for every agent, while pipeline() streams each item through its stages without waiting for the others. Community guidance is to default to pipeline() for multi-stage per-item work and add a barrier only when a stage truly needs all earlier results, such as deduplicating across all findings or deciding to exit early. One community writeup shows a mis-designed pipeline costing roughly twice the tokens of an equivalent barrier design, so the choice affects cost as well as speed. A useful test from the same sources: if you cannot sketch a non-trivial flowchart with parallel branches, loops and data handoffs, you probably do not need a workflow.
Common mistakes and troubleshooting
Using a workflow for a small task. One agent in a normal session is cheaper and often better.
Confusing the primitives. A hook cannot make decisions, a skill cannot enforce ordering, and a subagent is not a workflow.
No stop condition. Always say when to stop, for example "two rounds in a row with no progress".
Trusting the final report. Re-run the tests and read the diff. Ask Claude to show evidence, such as test output, instead of asserting success.
Permission prompts stalling a long run. Add the tools the agents need to your allow rules before starting.
An agent that stalls. The runtime restarts it automatically, up to five times, and the progress view shows a retry label. For genuinely slow work, pass stallMs on that agent() call.
A run that hits your usage limit. In interactive sessions signed in with a subscription, the run pauses and resumes after the reset (v2.1.271 or later), with conditions listed in the docs. Other modes fail the affected agent instead.
Workflow commands missing. Check for disableWorkflows, the CLAUDE_CODE_DISABLE_WORKFLOWS variable, or an organization policy. On Pro, check the /config toggle.
Resume surprises. If you edit a script, the first agent whose prompt changed and every agent after it run again. A failure mid-fan-out reruns agents that started after it, even finished ones.
Limitations, security considerations and best practices
Documented limits
Constraint
Value
Concurrent agents
16 by default, fewer when Claude Code has fewer CPUs; adjustable from 1 to 256
Items in one parallel() or pipeline() call
4,096
Agents per run
1,000
Mid-run user input
None. For sign-off between stages, run each stage as its own workflow
Script access
No direct filesystem or shell access; agents do the reading, writing and commands
Modules
A script containing import() fails before the run starts
Cost
This is the biggest practical risk. A run can use far more tokens than the same task in conversation, and runs count toward your plan's limits. Claude Code shows a Large workflow warning when a run schedules more than 25 agents or its projected total passes 1.5 million tokens, but the warning is advisory and does not pause anything. To control spend:
Pilot on a small slice, such as one directory.
Watch per-agent token usage in /workflows and stop the run if it grows.
Check /model before a large run, and ask for a smaller model on stages that do not need the strongest one.
Choose a smaller size guideline if you want fewer agents.
Remember that the 5 minute prompt cache for workflow agents can be extended to one hour with subagentPromptCacheTtl, at a higher cache-write rate.
Security
The ultracode keyword only starts a workflow from a prompt a human types. Since v2.1.210 it does not fire from webhook payloads or relayed pull request comments, which closes a route for untrusted text to launch large runs.
Workflow agents get the same permission checks and sandboxing as other tool calls. A broad allow list of a hundred agents is a large blast radius, so scope your rules and prefer auto mode over bypass.
Community guidance for triage workflows is to quarantine agents that read untrusted content (issues, emails, scraped pages) so they cannot take high-privilege actions; separate acting agents do that.
Run migrations on a branch and review pull requests before merging.
Best practices
Start in one directory, then scale.
Put verification in the prompt: a type check, tests, or an adversarial review step.
Keep durable rules in CLAUDE.md, enforce must-happen actions with hooks, and keep prompts specific about files, constraints and what "done" means.
Save workflows that worked and commit them under .claude/workflows/.
Use /clear between unrelated tasks, and rewind with checkpoints (Esc twice or /rewind) instead of piling corrections into one session. Checkpoints do not track changes made through Bash, so they do not replace git.
Workflows compared with the Agent SDK
You could already script multi-agent flows with the Agent SDK or claude -p. A community comparison draws this line: the SDK is for agents you ship inside your own product, while dynamic workflows coordinate the agents doing your own work inside Claude Code. A hand-built harness has to cover every edge case in advance, while a workflow is written for the single task in front of it. Open-source projects that make workflow scripts portable to other agents exist, but they are unofficial, so verify them before use.
Frequently asked questions
Are Claude Code dynamic workflows the same as subagents?
No. Subagents are workers. A workflow is a script that orchestrates many of them, and the script, not Claude, decides what runs next.
Do I need agent teams enabled?
No. Workflows are independent of the experimental agent teams setting.
Which plans include dynamic workflows?
The official docs say all paid plans, plus API access and the major cloud platforms. They are on by default for Max, Team and Enterprise, and Pro users enable them in /config. Plan details change, so confirm in the docs.
Can I reuse a workflow?
Yes. Save it from /workflows and it becomes a slash command. Saved workflows take structured input through the args global.
Can I resume a run after closing Claude Code?
Within the same session, yes. If you exit and later resume the session with Claude --resume, you can ask Claude to relaunch the workflow and complete agents' replay from saved results. A fresh session starts the workflow over.
Can I turn workflows off?
Yes, through /config, "disableWorkflows": true or the environment variable. Admins can disable them organization-wide.
Will workflows make my coding faster?
For wide, parallelizable work, often yes. For narrow, sequential work, usually not, and they will cost more.
Conclusion
Claude Code dynamic workflows give you orchestration that lives in a script you can read, rerun, save and share, instead of in a chat transcript. They suit codebase-wide audits, large migrations and any work that needs independent verification. They are the wrong tool for ordinary feature work, where plan mode, a lean CLAUDE.md, a few hooks and one focused subagent cost far less.
Start small. Run /deep-research once to see the shape, try a workflow on a single directory, read the script before approving, and verify the result yourself. This area changes quickly, so confirm version requirements against the official Claude Code documentation before you build on them.
Top comments (0)