36:27Mark Kashef · Tutorial
Claude Code + AWS Bedrock = Enterprise AI
A 36-minute blueprint for moving a personal AI agent stack into a locked-down, compliance-ready AWS environment — built over a month and nearly 10 million tokens.
June 25thThe argument in one line.
Dynamic workflows are not just a way to spawn more agents: they let Claude Code build a custom task harness on the fly, and knowing the six shapes that harness can take is what separates reliable multi-agent work from expensive trial-and-error.
Read if. Skip if.
READ IF YOU ARE…
- You use Claude Code regularly and have hit context window limits, agent laziness, or goal drift on longer tasks.
- You want a structured vocabulary for multi-agent prompting with concrete, copy-paste prompts.
- You run research, due diligence, fact-checking, or ranking pipelines where parallel independent judgment matters.
- You want to share reusable workflows with a team as versioned skill files.
SKIP IF…
- You are not using Claude Code at all; these patterns are Claude Code-specific, not general LLM theory.
- You are looking for deep technical internals rather than practical how-to prompts.
The full version, fast.
Single-context Claude Code sessions degrade on complex tasks through three failure modes: agentic laziness, self-preference bias, and goal drift. Dynamic workflows solve all three by spinning up independent agents each with a clean context window. The six patterns are composable primitives that can be stacked in a single prompt for compound reliability. The honest caveat: workflows consume far more tokens than single sessions and should only be reached for when a single agent would genuinely fail.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 00:33
01 · Intro
Six patterns from Anthropic's internal masterclass; TLDR promise.
00:33 – 01:11
02 · The Real Unlock
Claude Code builds a custom harness on the fly, not just spawns agents.
01:11 – 02:23
03 · Three Failure Modes of One Context Window
Agentic laziness, self-preference bias, and goal drift all stem from a single overloaded session.
02:23 – 03:01
04 · How Dynamic Workflows Fix It
Separate Sonnet 4.6 agents each get a clean context window; problems are isolated.
03:01 – 04:22
05 · Pattern 1: Classify and Act
A receptionist classifier routes incoming tasks to the correct specialist; inbox triage prompt shown live.
04:22 – 06:33
06 · Pattern 2: Fan Out and Synthesize
Parallel agents on independent sub-tasks, merged with citations; deep research and due diligence prompts.
06:33 – 08:40
07 · Pattern 3: Adversarial Verification
Three skeptic agents cross-reference output against a rubric; fact-check blog post prompt live.
08:40 – 10:30
08 · Pattern 4: Generate and Filter
Over-generate ideas with parallel agents, apply judge plus rubric to winnow; video title prompt.
10:30 – 13:00
09 · Pattern 5: Tournament
Pairwise head-to-head in bracket rounds, each match a fresh agent; resume ranking example.
13:00 – 14:12
10 · Pattern 6: Loop Until Done
Spawn new agents until outcome condition is met, no fixed pass count; flaky test hunting.
14:12 – 16:46
11 · Stacking Patterns
Fan out plus adversarial verify plus loop until done chained in one prompt; CRM onboarding audit.
16:46 – 17:36
12 · Sharing as a Skill
Every workflow is a JS file; package with SKILL.md and rubric into a shareable folder.
17:36 – 18:00
13 · Token Budget and Saving
Use /workflows to inspect running ones; set explicit token caps; /goal adds a hard stop condition.
18:00 – 18:41
14 · When NOT to Use Workflows
Workflows burn tokens; only reach for them when a single agent would genuinely fail.
18:41 – 19:24
15 · Recap
Free prompt pack linked; live community module on deeper workflow use cases.
Lines worth screenshotting.
- The real unlock of dynamic workflows is not more agents but Claude Code building a bespoke task harness on the fly.
- A single long session degrades through three failure modes: laziness, self-preference bias, and goal drift.
- Self preference is the silent killer: a session cannot objectively audit its own output, just as a person cannot grade their own work objectively.
- Adversarial verification requires the checking agent to be categorically different from the agent that made the output.
- Generate and filter works because going from 1000 ideas to 3 is faster and more reliable than going from 10 to 3.
- The tournament pattern is the only approach that gives you an audit trail of every decision branch, not just the final winner.
- Loop Until Done is most powerful when the exit condition is outcome-based, not count-based.
- Stacking fan-out, adversarial verification, and loop-until-done in one prompt creates compounding reliability without manual orchestration.
- Every workflow is a JavaScript file: shareable, versionable, and composable with a SKILL.md and a rubric.
- Workflows cost more tokens than single sessions; reach for them only when a single agent would genuinely fail.
- As models improve, the threshold for needing a workflow will keep rising; swarm patterns today will collapse to single prompts later.
- Setting an explicit token budget with a hard cap prevents runaway spending on open-ended loop-until-done workflows.
Six shapes every complex agent task can take.
WHAT TO LEARN
Before reaching for a multi-agent workflow, name which failure mode you are solving: that single diagnosis tells you which of the six patterns to use.
03Three Failure Modes
- Single-session Claude degrades on long tasks in three predictable ways: it stops early, grades its own work too charitably, and forgets the original brief after many compactions.
- Self-preference is the subtlest failure mode: any output-producing session will evaluate its own work more favorably than an independent reviewer would, regardless of quality.
05Pattern 1: Classify and Act
- Classify and act is the right pattern when incoming tasks are heterogeneous and need to be routed to different specialists before any action is taken.
06Pattern 2: Fan Out and Synthesize
- Fan out and synthesize works when sub-problems are truly independent: each agent gets a clean context and returns a structured result with source citations, then a merge step reconciles them.
07Pattern 3: Adversarial Verification
- Adversarial verification requires the verifying agent to be a different agent from the one that produced the output, or you have replicated the self-preference problem in a new wrapper.
08Pattern 4: Generate and Filter
- Generate and filter is most useful wherever taste or judgment is required: the more options you generate, the better the top few you can extract.
09Pattern 5: Tournament
- The tournament pattern is the cleanest way to rank a large set of items because each head-to-head comparison is isolated and auditable, reducing context-window bias.
10Pattern 6: Loop Until Done
- Loop until done should always be paired with an outcome-based exit condition and an explicit token budget cap; without both, it can run indefinitely.
11Stacking Patterns
- Stacking patterns is where compound reliability comes from: fan out to gather, adversarially verify to prune, loop until done to confirm, all in a single prompt.
14When NOT to Use Workflows
- Workflows are expensive by design; the honest filter is whether a single capable agent would genuinely fail the task, not whether a workflow would feel more thorough.
Terms worth knowing.
- Dynamic workflow
- A Claude Code feature where Claude designs and builds its own multi-agent orchestration harness on the fly, customized for the task at hand.
- Agent laziness
- A failure mode where a single-session Claude confirms it will complete many tasks but stops after only a subset without completing the rest.
- Self preference
- A failure mode where a Claude session evaluating its own output rates it more favorably than an independent reviewer would.
- Goal drift
- A failure mode where the original task framing degrades across many compactions until the session loses alignment with the initial objective.
- Classify and act
- A workflow pattern where a lightweight classifier agent routes each incoming task to the appropriate specialist handler.
- Fan out and synthesize
- A workflow pattern where a task is split into independent sub-problems, each handled by a parallel agent, and results merged into one output.
- Adversarial verification
- A workflow pattern where separate skeptic agents review output against a rubric, specifically tasked with finding flaws.
- Tournament pattern
- A workflow pattern where items compete in pairwise head-to-head comparisons handled by fresh agents, advancing winners through bracket rounds.
- Loop until done
- A workflow pattern where new agents are spawned iteratively until a specific outcome condition is met, with no fixed pass count.
- Harness
- The orchestration scaffolding Claude Code builds for a task: the agents, routing logic, and data flow assembled specifically for that job.
Things they pointed at.
00:00linkAnthropic Dynamic Workflows Masterclass
Lines you could clip.
01:40
“You're basically asking a single session that's currently running how its code is doing. It's going to be biased like a person who creates their own deliverable.”
09:05
“It's easy to go from a thousand ideas to three versus to go from ten to three.”
18:10
“Otherwise you are just lighting money on fire to feel fancy.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphoranalogy
00:00There are six patterns that separate the people who actually get how to use dynamic workflows to their fullest potential versus those who just turn it on once and never use it again. The engineers at Anthropic that both designed and built this feature just released a full masterclass on how to get the most out of it.
00:16So in this video, I'm gonna break it down for you and give you the TLDR so you don't have to read it yourself and you can just take all the nuggets. I went through the whole thing and pulled the six core design patterns that everything else is built on. And on top of that, it has some Easter eggs on when and when not to use workflows as well as how to share them with a team.
00:33If you're ready to take your workflows to the next level, then let's dive in. Now most people think that a dynamic workflow is just a fancier way to spin up agents, but that's not the real unlock. The real unlock is an understanding that this is a brand new way for Claude Co.
00:47To design and create , which is like a little machine that can be custom built for whatever task that you hand it. And once you understand these six shapes that this machine can take, then you can apply them to pretty much any scenario. But before I can even go through all of the patterns at length, it's important to understand the core mechanics underneath them because they are the very reason why this feature even exists.
01:11So normally, when you give Claude code a task and you're only dealing with one context window, that context window is a glorified short term memory for that particular task. And for most things, this works just fine. But when you have longer running tasks or more complex tasks and you find yourself half a 600,000 tokens into a conversation, this is when things start to unwind.
01:33And then you have things that are called agent laziness where you give it 15 tasks, it says it's going to do said tasks, but it only actually accomplishes seven. And the next one is self preference, and this is a huge one. So this is essentially having Claude code audit itself and saying that it did a great job.
01:50You're basically asking a single session that's currently running how its code is doing or the quality of its output. It's going to be biased like a person who creates their own deliverable to say that it's better than it actually is. And the last one is goal drift, where pretty much you have an overall goal at the beginning of a session, but after a long running conversation and tons of auto compactions and tool calls and summarizations, that detail that you had at the very beginning that made it fully synthesize and understand what it's trying to accomplish and how it should do so starts withering away.
02:23So a dynamic workflow fixes all of these problems by not focusing on one single cloud session, but instead spins up a series of agents, many of which will be SONNET 4.6 by default to go and have individual context windows to solve each problem separately. So now we can get into the nitty gritty, and these are the six core patterns.
02:43One is called classify and act. The second is fan out and synthesize. Then we have adversarial verification, generate and filter, tournament, which is my favorite, and then loop until done.
02:54For each one of these, I'm gonna walk you through what it is, how it works, and much more importantly, how you can actually use it. We'll start at the simplest one and work our way from there. So for the first one, classify and act.
03:05This is pretty much having the equivalent of a receptionist at the front door classifying what a task should be grouped into or which agents are responsible for said task. So it's meant to just have a very basic language model right here.
03:20We have the task. This has some form of system prompt. Once the system prompt filters, which is the responsible agent, this becomes the critical path or the chosen path.
03:29So a common example of when you'd use this is something like inbox triaging. We have an email come in and then the AI decides, is this a bug? Is this a request for a refund?
03:39Is this an upgrade request? Or something along those lines. Once it classifies it, it will route it to the right agent.
03:45Another way to think about this is that you're basically with that task or input before it goes to the next stage. So at the very beginning, you have a reader agent, then you have a ticket, and then it gets pushed on to the next part of the process where you have a trusted agent go and take action upon that input.
04:03The practical application prompt would be build a workflow that triages my inbox in name of folder by spawning a classifier agent that reads each ticket and routes it to a bug, refund, lead, spam handler, and deducing, basically removing duplicates against what is already tracked before any handler acts.
04:22And then we tell it how the quarantine process should be executed. The next process is called fanning out and synthesizing, and this is essentially the process of taking a task, breaking it into micro parts optimized for individual mutually exclusive agents to take care of them, and then you synthesize all of their individual results, their individual contributions, and then you bring them to one overall result.
04:45So a very practical and common application is deep research where you basically have one core thing you're trying to understand. So let's say you wanna research the best ways to use agent harnesses.
04:56It would go and see what are all the different lenses for this problem, and let's assign one agent by default, most likely, a Sonnet 4.6 agent for this angle of this research question. And once they all work in parallel, we'll retrieve all their answers at the very end just like sub agents and then have one overall result.
05:15Other than research, you could also apply this to a due diligence scenario where you have financials, contracts, legal, then you have some agent, and each one of those agents pulls out all the salient points for some form of red flag memo. But going to the terminal, this is a good prompt application of this concept.
05:32Build a workflow that does due diligence on the data room in folder by fanning out, keyword here, one sub agent per folder, each in its own clean context so the files never cross contaminate, and have every agent return a structured summary with the exact source path for each finding.
05:50So we're creating basically citations within documents. Then run a barrier synthesized step that waits for all of them to finish and merges their outputs into one-sided due diligence demo at name of your desired demo where every claim links back to the file it came from.
06:05So a little bit of extra emphasis here on the citations. By the way, if you're enjoying this content, you like the way they break down all these concepts, then you're going to love all of the exclusive content you'll find in my Claude code living course. I add at least one brand new module every single week that you'll never see on YouTube.
06:22So if you want access to that, our team of coaches included in your membership along with tons of other goodies and great builders you'll find in there, then check out the first thing down below, and I'll see you inside. Alright. Back to the video.
06:34Now this next example is one that I really want you to retain. It's called adversarial verification and it's meant to plug a hole in the issue of self preference.
06:43So instead of having Claude code think it's awesome all the time, you very intentionally employ three different skeptics or devil's advocates to look at the output and then cross reference it against some checklist or rubric. So one extra step that you can take here is before you even execute the workflow is you create the proper rubric.
07:03Because once you do the rubric, it's basically your pseudo plan that your other agents can push against and play devil's advocate using that as its core source. The natural application of this is fact checking. So if you produce anything with AI, like a blog or an article or anything where you're worried about all the facts being a 100% coherent and correct, running this kind of devil's advocate at scale can help you find any issues or any controversial statements prematurely.
07:30So if you wanna see a tactical example of this, imagine that you have a blog that you're drafting, and then from this blog, you have an extractor. And then from this extractor, you pull out individual claims. Once you have the claims, you need to decide if they're factual or non factual, then you spin up a series of sub agents.
07:47Each one checking one individual claim and going down a rabbit hole. And once they come back with their false positives, false negatives, then you can create a verified report on what needs to change in this block. If you want to execute this, you could use a prompt like this where you say, use a workflow to go through my blog post and verify each factual and technical claim before I ship it.
08:10Have one agent extract each claim into its own item, then for every claim, off a separate agent that checks it against the real source. So we're making sure that we don't have individual agents also having self preference bias.
08:23So the rest of the prompt basically walks through the behavior of making sure that when it's done, give me back the list of claims that have failed and the exact reason why each failed so that I know what to fix. And ideally, where the bias of the language model that might have drafted or written that blog post might have come from.
08:40And the next pattern is called generate and filter. And the whole point of this is to spin up a series of agents to over generate a series of ideas, project names.
08:49It could be whatever you're trying to ideate about. And once you have those ideas, it's easy to go from a thousand ideas to three versus to go from 10 to three. So it just basically gives you more variety.
09:01So I could use it, for example, to say, what should I title this video so it communicates the concept without being clickbaity? Find me a balanced 500 titles that have performed really well on YouTube in the past six months. So you practically use this wherever taste is required.
09:17So if you need your opinion on a cold email opener or the name of a brand new product or where you should execute a certain pop up offer. This would be a helpful way to go and do the research individually.
09:29Maybe do some market research analysis. Maybe you hook up some skills for these agents to be able to use to survey, scrape, do whatever they need to come back with the richest information possible, and then you synthesize and digest that down to just a few ideas.
09:44And if you wanna get fancier with it, then you can always integrate the judge in the workflow. So you have a series of agents, spin up all the ideas, then you have a series of judges that then critique all the ideas, then you have some rubric, again, ideal that you put together so you can quality control the quality controllers, and then you get the tested synthesized picks at the very end.
10:04To apply this, you could send over a prompt like this where it says, use a workflow to brainstorm a 40 video title and headline angle options for the topic in name of topic with one generator agent, then hand them all to a judge agent that scores every option against a series of criteria. Then at the very end here, we say the generator that brainstorms and the judge that scores must be different agents.
10:27So I might be spoon feeding or overturning it what to do, but it's never a bad idea to overexplain yourself to a language model. Now like I said before, pattern five is my favorite, and it's called the tournament pattern. And the way it works is this.
10:41Instead of dividing up the work amongst multiple agents like we saw in prior patterns, this one takes single ideas, sends them to fresh new agents, and asks it some controversial question. Should we go with this decision or not?
10:54And then this agent will go through every single reason, which one of the two options, it could be three options, four, is the best and why. And then all of the good ideas or the good proposals or good decisions move on to the next round until you get to the final bracket.
11:10So this will keep going pairwise until we get to the very end where we have a final. Then at each stage, we have an unbiased agent with a fresh context window. Instead of having Claude code look at 500 different decisions, its context window, its memory, its auto compaction, all that will lead to less accurate decisions.
11:30So when you break apart all the possible decision space into all these separate agents, you have a different way to also trace how a decision is made. And you could probably imagine the example use case of where this would be helpful. Imagine you have 5,000 resumes, and instead of shoving those 5,000 resumes through a typical applicant tracking system or one Claude code session where it will inevitably find bias, context window issues, bloating.
11:56You basically break apart all those resumes into specific stacks. Do we pick this person or this person and explain why? Applying this, you could have a thousand different items, and then you have different rounds.
12:08Round one could be assessing all items based on x criteria. Then the next round would be on b criteria, and then we would keep going until we get to the final round.
12:18So the one key caveat here is that each round could technically have its own rubric. So it doesn't have to be seven, ten, 50 rounds with the exact same criteria.
12:29And a prompt for this could say, use a workflow to rank every resume for the back end engineer role by running a tournament of pairwise comparisons against a rubric instead of scoring each one cold where each head to head match is its own comparison agent and the deterministic loop holds the brackets so only the running order stays in context.
12:48So if you wanna steal a lot of my wording here, you're gonna be able to access all these prompts in the second link down below, so don't worry about it for now. But we're basically just setting the tone for this whole bracket to transpire. Now the last pattern is called loop and done, and this is very similar to something like slash goal where all you do is instead of telling the agent, go and do x 10 times, you just say, don't stop until you reach this specific outcome.
13:14So if you have brand new findings for a particular matter, it will keep going and spin up brand new agents to go through, double check, triple check until you reach the specific desired result. So maybe you have a bug that occurs in a platform you've put together. Maybe you vibe coded it, and maybe this bug happens once every 30 times, but you can't usually spot it.
13:33You have to keep refreshing. You have to keep trying different combinations to reproduce the bug. You could theoretically say, go through and run this until you receive the bug, and then once you get the bug, try and trace what's happening and how we can resolve it.
13:48If we need another application, imagine you send this loop and done on a wild goose chase to go through all of your conversations, your JSONL files that represent your cloud code sessions, and you say, keep looking through every single one of these conversations for every pattern I've made until you have a comprehensive non duplicative list of every single thing that I could improve to be that much better at Cloud Code.
14:12So you could say something like, build a workflow that hunts down a flaky test that fails maybe one in 50 runs, keep forming theories about the cause and adversarially testing each one in its own isolated work tree. And when it comes to the prompt, it could look something like this.
14:28Build a workflow that hunts down what's called a flaky test in the test folder that fails maybe one in 50 runs. Keep forming theories about the cause and adversarially testing each one in its own isolated work tree.
14:42This is basically a separate session for an agent. Looping and spawning new attempts with no fixed pass counts. So basically telling it, we are not telling you to go check this 10 times or 20 times.
14:53Keep checking it until this specific result is achieved. Now those were the six core patterns, but this is how you go from just knowing about them to actually becoming dangerous with them, which is stacking them on top of each other. So imagine you have a realistic scenario where you vibe quoted some CRM, and this CRM has an onboarding flow for clients.
15:12And you wanna find ways to improve that onboarding flow, make it very thoughtful, and think of different order consequences. Maybe you go and say fan out a series of agents to look at the code base and pull out all the insights on what should change and why. And then once that is pulled out, then you move on to pattern number three, which was the adversarial verify step.
15:32So now it has a series of devil's advocates that goes against all the findings that were found. Then from that step, maybe you add on a loop until done. So maybe you combine a slash goal in the scenario, and then you apply that to this specific circumstance.
15:47So maybe you have a process that keeps going until it can't find any more optimizations that it could possibly make given the specific avatar who's using the platform. The best part about this is that you don't have to design it by hand. It's really a matter of just using the keywords in the right way to get the confirmed result or the ideal result.
16:04If you wanted to put all of this into one single prompt, you could say something like, build a workflow that audits every file under code base, fans out one agent, keyword right here, fans out per file, has a separate agent try to refute each of the findings against the codes, and this is our adversarial verify, and loops until a clean pass turns up with no new issues.
16:28Return only the confirmed issues each with the file and the exact line, then for good measure, you could add slash goal. Do not stop until a full clean pass finds no new issues. Now do you need this last sentence?
16:40Maybe not. It would get the idea, but if you wanna add it for an additional layer, then you can absolutely do so. And like I said before, you can also share workflows very similar to how you share skills.
16:50And pretty much every workflow is purely a JavaScript file. And when you combine this JavaScript file with your skill file and maybe any additional markdown file that it depends on, all you'll get is one overall folder with the skill m d, the JavaScript file, and anything else that's involved.
17:08So it will look something like this. If we go into this folder, you'll have this rubric, you'll have the SkillMD, and then you'll have this verify claims workflow dot JavaScript file.
17:19If you're not familiar, if you ever wanna save a workflow, all you'd have to do is go into let's say we run this. So we do slash workflows.
17:29This would show you any workflows running at the moment. And then while this is running, you could always save that specific workflow. Once it saves, it'll allow you to store this as that JavaScript file that I referred to before.
17:41The one additional thing that they write in the guide is that you can basically always tell Claude code what its budget is when it comes to token usage because this is a very token consuming feature which should be used sparingly for very large use cases or use cases that have different layers of complexity.
17:59So one of the examples of when to not use a workflow are for basic tasks. So if you have a platform and you have a series of buttons that you wanna change the color of or you want them to pulsate when you click on them, you wouldn't spin up an agent team just to do that.
18:14You could do that individually just using basic prompts. So as we get infinitely better models and we go from 4.8 to 4.9 to five, you'll be able to do a lot more with a lot less. So you won't need agents for all tasks, but when it's time to use the power of agents, they will be there and you'll be able to use these swarms for much more complex matters.
18:33So hopefully, breaks down and demystifies all the power and all the potential that you might be leaving on the table by not using these patterns in your day to day. Like I said, you'll find all the prompts I showed you along with some additional goodies like an example of that skill folder with the workflow inside of it in the second link down below so you can use it, get started, and start leveling up your workflows like I promised.
18:55If you wanna take your AgenTic workflows and AgenTic OS systems to the next level and you wanna master Cloud Code, then make sure you check out the first link down below for my early adopters community. This week's upcoming live module will be a deeper dive on dynamic workflows and how I've used it myself for things like travel and personal stuff outside of core business use cases.
19:15And for the rest of you, if you found this helpful and novel, I'd super appreciate a like on the video and a comment if you so choose, and I'll see you in the next one.
The Hook
The bait, then the rug-pull.
Anthropic's own engineers built a masterclass on dynamic workflows and released it quietly. This breakdown does the reading for you: six core patterns, the three failure modes they fix, and one honest warning that most workflow tutorials skip entirely.
Named ideas worth stealing.
02:29list
Six Claude Code Dynamic Workflow Patterns
- Classify and Act
- Fan Out and Synthesize
- Adversarial Verification
- Generate and Filter
- Tournament
- Loop Until Done
Six composable agent orchestration patterns that solve the three failure modes of single-context Claude sessions.
Steal forAny complex multi-step agentic task where a single session would degrade
01:11list
Three Failure Modes of One Context Window
- Agentic laziness
- Self preference
- Goal drift
The three ways a single long Claude Code session breaks down on complex tasks.
Steal forDiagnosing why your solo agent prompt is not delivering reliable output
How they asked for the click.
VERBAL ASK
06:33product
“check out the first thing down below for my Claude code living course”
Mid-video at ~6:30; briefly stepped out of the pattern breakdown to plug the paid community, then returned cleanly. Low-friction ask with clear value prop.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
