Tari Ibaba

You think Claude Code makes you code faster — but you don’t realize you’re barely scratching the surface.

Just sending prompt after prompt to Claude Code will get you nowhere.

When you ignore features like Loops, you end staying far behind what your potential could be — in speed and accuracy and everything that moves you closer to your goals as a developer.

Loops are like the holy grail of AI automation.

You’re no longer just manually prompting and hoping to get exactly what you want.

Now Claude will actually do the prompting for you — over and over until it gets the exact prompt that meets your exact requirements.

It’s an absolute game changer.

You are going from regular prompt engineering — to full-blow loop engineering.

No more step-by-step instructions — now you define precise goals, verification criteria, and stopping conditions.

And it doesn’t stop at prompting.

What are Claude loops exactly?

Claude Code loops are the iterative execution cycles in which Claude repeatedly:

• Reads the current project context
• Uses tools such as terminal commands or file editing
• Evaluates the results
• Repeats the process until a predefined stop condition is met

Instead of acting like a one-shot chatbot, Claude functions as an autonomous background agent capable of completing tasks with minimal human intervention.

The four types of loops

Claude Code gives you four primary loop patterns.

1. Turn-based loops — Complete everyday tasks reliably

Every prompt already runs inside a turn-based loop by default.

Claude gathers context, performs edits, executes tools, verifies its work, and returns a response.

Example:

Scenario: Fixing a bug in a login form.

Prompt:

Fix the bug preventing users from logging in with Google OAuth.

What Claude does:

• Reads the authentication code
• Identifies the issue
• Updates the implementation
• Runs relevant tests
• Returns the completed fix

The loop ends once Claude has finished your task and gives you a response.

These loops are ideal for everyday tasks such as debugging, refactoring, and implementing small features.

2. Goal-based loops — Make sure Claude explicitly finishes the job

Goal-based loops continue working until a measurable objective has been achieved.

Example:

Scenario: Eliminate all failing tests.

Prompt:

Keep working until every unit test passes.

Do not stop if tests fail—fix the issues and rerun the test suite until all tests are green.

What Claude does:

• Runs the test suite
• Finds failing tests
• Makes code changes
• Reruns the tests
• Repeats until every test passes

Instead of stopping after one attempt, Claude keeps iterating until the success criteria are met.

Rather than generating a single answer, Claude keeps iterating until the defined outcome is reached.

3. Time-based loops — Easily automate recurring development tasks

Time-based loops execute on a schedule, similar to cron jobs.

For example:

Scenario: Monitor a pull request throughout the day.

Command:

/loop 15m check my open PR, address any new review comments, rerun CI, and commit fixes if needed.

What Claude does every 15 minutes:

• Checks for new reviewer comments
• Updates the code
• Runs tests
• Verifies the build
• Waits until the next scheduled run

This is similar to a cron job, except the scheduled task is powered by an AI agent rather than a static script.

Claude periodically revisits the task without requiring another prompt.

4. Proactive loops — Let Claude continuously maintain your projects by itself

Proactive loops are the most autonomous.

Instead of waiting for your instructions, they continuously handle repetitive engineering work.

For example:

Scenario: Automatically maintain a repository.

Workflow:

Every once in a while, Claude:

• Scans the repository for outdated dependencies
• Opens upgrade pull requests
• Fixes simple merge conflicts
• Runs the test suite
• Closes duplicate issues
• Updates documentation if APIs have changed

No developer prompt is required. The workflow runs continuously based on a schedule or repository events, keeping the project healthy with minimal manual intervention.

This shifts AI from reactive assistance to proactive software engineering.

Evaluator-driven verification — Reduce bugs by making Claude prove its work

One of the biggest challenges with language models is premature satisfaction—assuming a task is complete before proving it works.

Claude Code addresses this with external verification.

Instead of relying on Claude’s confidence, an evaluator checks the outcome using objective signals like:

• Unit tests
• Linters
• Browser automation
• Performance checks

If verification fails, Claude automatically returns to work until the required checks pass.

Cron-like AI workflows — Turn Claude into a scheduled engineering assistant

Time-based loops effectively turn Claude into a scheduled AI engineer.

A recurring loop can:

• Review open pull requests
• Respond to new review comments
• Apply fixes
• Re-run tests

You can step away while Claude continuously manages routine engineering work in the background.

Deterministic API control — Build reliable autonomous agents that stop at the right time

Claude Code loops are controlled by structured API signals rather than natural-language responses.

States such as stop_reason: "tool_use" and stop_reason: "end_turn" determine whether Claude should continue working or exit the loop. This deterministic control flow reduces premature exits and prevents runaway execution.

Tiered cost optimization — Scale long-running AI workflows while keeping costs low

Long-running loops can become expensive if every iteration relies on a frontier reasoning model.

To reduce costs, routine tasks—such as gathering context or running shell commands—can be delegated to smaller, faster models. More capable models are reserved for complex reasoning and code changes, making autonomous workflows more efficient.

Loops are the future — Spend less time prompting and more time shipping software

With loops, instead of waiting for prompts, Claude can monitor repositories, manage pull requests, triage issues, and perform continuous maintenance with minimal supervision.

By combining iterative execution, automated verification, deterministic control flow, and scheduled automation, loop engineering enables AI agents that work toward measurable outcomes—not just generated responses.

The result is an AI that behaves less like a chatbot and more like a persistent engineering teammate.

Claude Code Dynamic Workflows will change the way developers code with AI forever.

It fixes all the problems we’ve had to deal with when trying to use the same agent to do everything — or when trying to make multiple agents work together.

It combines hard-coded code and dynamic LLMs in a way we’ve never seen before — to get the absolute best of both worlds.

Dynamic Workflows allows Claude write its own JavaScript orchestration scripts on the fly and spin up tens to hundreds of parallel subagents to tackle giant tasks end-to-end.

It doesn’t just spawn sub-agents randomly — it deploys them in incredible structured and sophisticated ways.

And the sub-agents are not just doing simple divide-and-conquer code generation like we’ve been seeing.

They are intelligently combining themselves in a way that’s perfectly customized to whatever massive task we give them.

Some of them might aggressively review the code another agent generated — some might be there to pick the best code generated among a set of other agents.

Let’s dive deeper into Dynamic Workflows and see all the ways it can level up the workflows of so many developers.

1. Fixes all the biggest failures of single-context LLMs

Traditional AI agents operate inside a single conversation, which creates three major failure modes.

Defeating agentic laziness

Give one agent a task like reviewing 50 files for a security issue and it eventually becomes difficult to track progress.

Tasks get summarized, details are missed, and the model may prematurely declare success.

Dynamic Workflows solve this through decomposition. Instead of one agent handling 50 files, Claude launches 50 focused subagents. Each agent sees only one file and one objective, while the orchestration layer manages the larger task.

Crushing self-preferential bias

In traditional workflows the same model often generates and reviews its own work.

Dynamic Workflows separate these responsibilities. One agent builds, another reviews, and a third may challenge both. Because reviewers operate in independent contexts, they evaluate outputs against the requirements rather than defending previous reasoning.

Preventing goal drift

Long conversations cause important constraints to disappear over time.

Requirements like maintaining backwards compatibility or preserving performance gradually get compressed out of context.

Dynamic Workflows keep agent conversations short and purpose-built, ensuring every worker remains tightly aligned with the original objective.

2. JavaScript-powered deterministic decomposition

This is one of the biggest breakthroughs with Dynamic Workflows.

Claude doesn’t just spawn agents on the fly — it first writes a custom orchestration program.

LLM’s are great but they can be unpredictable — and there is no guarantee on how they tackle a huge goal.

With this JavaScript orchestration layer, the workflow’s structural control flow is 100% deterministic and predictable.

The file calls multiple JavaScript functions, like agent():

• agent(prompt, options): Spawns an isolated subagent. Can enforce structured JSON data using a schema

We know exactly what is going to happen at the high-level — while letting the individual sub-agents decide how they go about the lower-level tasks distributed among them.

Instead of thinking and generating everything on the fly, Claude generates a JavaScript workflow that determines:

• How work is divided
• Which agents are created
• How outputs are verified
• How failures are handled
• How results are synthesized

Because these workflows are standard artifacts, developers can save, modify, version-control, and rerun them. Over time, teams can build libraries of reusable workflow harnesses and custom agent networks tailored to their engineering processes.

3. Advanced multi-agent design patterns

Dynamic Workflows can combine sophisticated agent architectures on demand.

Tournaments

Multiple agents attempt the same problem using different approaches. A separate judging agent evaluates the candidates and selects the strongest solution.

Adversarial verification

A dedicated reviewer is created with one goal: reject the output.

This agent actively searches for security vulnerabilities, logic flaws, hidden assumptions, and edge cases, creating a far more rigorous review process than self-evaluation.

Fan-out-and-synthesize

For large-scale tasks, Claude distributes work across dozens or hundreds of parallel agents operating independently. Once completed, the workflow pauses and synthesizes all outputs into a unified result.

This pattern is ideal for migrations, audits, documentation generation, and repository-wide code changes.

4. Powering massive engineering projects

The scale enabled by Dynamic Workflows is difficult to overstate.

It’s really hard to overstate the sort of massive scale you could get from using Dynamic Workflows.

A prominent example is the Bun runtime migration from Zig to Rust. Using workflow-driven orchestration, approximately 750,000 lines of Rust code were generated while maintaining roughly 99.8% compatibility with the existing test suite.

Projects that would traditionally span multiple quarters can increasingly become automated jobs running in the background for hours or days.

5. Built-in resumability and safety

Long-running workflows require operational reliability.

The runtime continuously tracks workflow state and subagent progress. If a crash or disconnection occurs, execution resumes from the last checkpoint rather than restarting from scratch.

To prevent runaway costs, the system also provides visibility into workflow execution, token consumption, and resource usage, while enforcing limits that stop recursive workflows from spiraling out of control.

Dynamic Workflows represent a shift from prompt engineering to orchestration engineering.

Rather than asking a single AI agent to solve increasingly complex problems, Claude generates a custom execution harness, launches specialized workers, verifies their outputs, tracks state, and synthesizes results.

The future of AI development is not single super-agent.

It’s dynamically generated teams of specialized agents coordinated by software the AI writes for itself.

This is incredible.

Claude Code just got a new command that makes it so much easier to build beautiful and breathtaking apps.

The new /design command brings all the most powerful features of Claude Design directly into Claude Code –to make designing an app as effortless as possible.

It’s perfect for whenever you want to add a new visualizable feature like a new screen.

The /design command in action in Claude Desktop — works in Claude Code too:

Before you’d just ask Claude to build the feature and then it gives the result — which you may or may not be satisfied with.

But now things have gotten a lot more sophisticated.

Now with the /design command Claude can generate and show you several visual directions in which it can take to implement what you’re asking:

The /design command makes multiple design suggestions:

You can inspect and refine them — then turn the direction you choose into frontend code.

The most interesting part of /design is that it doesn’t have to commit to a single interpretation of your prompt.

Claude can generate several distinct visual directions on one canvas. One dashboard might be dark, dense, and technical. Another might be minimalist and editorial. A third one might emphasize large charts and simplified navigation.

The artboards can also be interactive rather than static mockups.

Forms, calculators, charts, and other UI elements can demonstrate the behavior for you — giving you a chance to test the micro-interactions before you commit to an implementation.

You can also make lightweight edits directly on the canvas like adjusting text, spacing, layout, or individual elements. That makes the design itself part of the conversation with Claude.

Adjusting the generating design with auto-generated tweaks:

Another amazing ability it has is how it resolves all the unclear requirements before it starts generating — it doesn’t just make irritating assumptions.

A vague request like “make me a modern SaaS dashboard” leaves dozens of decisions unspecified: typography, density, brand feel, navigation style, and overall visual direction.

Instead of silently falling back to familiar AI design clichés the design workflow can ask targeted questions about themes, layout preferences, branding, and constraints first.

And the best part is how it can you use your existing codebase and all the visual components in as context.

Claude can inspect your project and figure out all the styling conventions, CSS variables, Tailwind configuration, design tokens, typography, and reusable UI components.

So instead of generating a mockup that looks completely detached from the current application, /design can now work directly with your existing design language.

There’s no more need to export a screenshot, manually rewrite a design specification, or describe the chosen layout all over again.

That means the all type scale, spacing, component choices, and styling you select can flow directly into your frontend code.

It makes experimentation so much easier — and drastically expands the limits of your creativity.

Making it incredibly useful as a solo developer where you have to be a product manager, designer, and engineer at the same time.

This is incredible.

Anthropic just made an insane change to Claude Code that will massively improve your productivity as a developer — although it might seem scary at first.

Claude Code now automatically executes commands and make tools calls by default when coding — no more stopping to ask for permission.

It won’t do this anymore:

And I know at first glance some developers will be seriously worried about this — won’t this potentially lead to disaster like file/database wipeouts or corruption from unsafe tool calls?

But actually this line of thinking is completely wrong — especially from what Anthropic discovered from their internal research.

In internal testing conducted by Anthropic across 1,053 paid participants, humans caught disguised dangerous commands only 13.6% of the time. After 50 consecutive permission prompts, detection dropped to roughly 5% as approval fatigue kicked in.

So it looks like it’s actually we humans we need to be concerned about when it comes to verifying commands.

So Claude Code now uses a background classifier to automatically know which commands are safe and which aren’t.

And the difference was absolutely insane — the automatic system was almost 7 times better at catching dangerous commands

Claude Code’s background classifier demonstrated a substantial security advantage, identifying and blocking 89% of destructive commands that might otherwise have been executed.

So of course once they saw the massive improvement it only made sense to make it the default in versions of Claude Code — Pro, Max, and Team.

And this change gives us so many benefits beyond just security.

Claude Code is no longer going to stall in its execution just to ask you to approve a command — you can finally experience the full value of long-horizon autonomous coding.

Anthropic reports that teams using it ship roughly 25% more pull requests because long-running agents can continue working without repeatedly waiting for human approval.

I found it pretty annoying at times — I would give Claude a prompt and expect it to be done when I come back — only to find out that it has barely even done anything — all because it’s waiting for me to approve a command.

I’m not the only one too:

Now I will have complete certainty that when I come back I will see results.

And also the background classifier is completely free — zero cost on all the complex logic or token usage of checking if a command is safe or not.

And free for all plans too.

Anthropic fully absorbs the computational cost of Claude Code’s background classifier, allowing Pro, Max, and Team users to benefit from continuous automated security checks without consuming any additional usage allocation.

So you don’t need to spend more just to be able to code with peace of mind.

And Auto Mode isn’t only looking for obviously dangerous shell commands — also helps defend Claude against indirect prompt injection.

So like if Claude reads a third-party package, webpage, or scraped file that has hidden instructions telling it to ignore the user and steal credentials.

Claude could potentially interpret those instructions as legitimate.

So this new Auto Mode adds another security boundary — the classifier always makes sure to compare Claude’s proposed action with the user’s original intent.

And this is especially important for autonomous agents because the more information they take in from the outside world, the larger their prompt-injection attack surface becomes.

Of course an AI supervising another AI creates its own problem — what happens when the security classifier repeatedly blocks Claude due to false positives?

Anthropic took this into consideration and built in an escalation mechanism.

If the classifier blocks three consecutive commands or reaches 20 blocked actions during one session, Claude Code automatically exits autonomous execution and returns control to the human.

One rejection might simply mean Claude chose a risky approach.

Twenty means something probably deserves human attention.

Auto Mode isn’t perfect tho — Anthropic still recommends human oversight for high-stakes production operations.

But the direction is really fascinating.

We originally put humans in the loop because we didn’t trust AI — then humans started clicking “Approve” without reading.

So now Anthropic has decided to put another AI in the loop to supervise the first one.

Most developers don’t realize just how many tokens Claude Code wastes by default in just trying to understand your codebase.

Every noisy search result, duplicate reference, and irrelevant file eats into your context before the real work even begins.

Increasing your API costs and slowing down responses significantly.

But luckily, we now have the incredible Language Server Protocol (LSP) integration to fix all this.

It’s one of the least talked about features that dramatically transforms how Claude processes your code and makes changes.

By swapping heavy text searches for instant AST queries, LSP cuts lookup times from 30–60 seconds down to a 50-millisecond response, delivering up to 900x faster code navigation speeds

With LSP Claude Code stops relying on text searches — it directly queries a language server that already understands your project’s structure. What you get is an AI assistant that behaves much more like a modern IDE than a just a chatbot. You get the best of both worlds.

LSP powers many IDE features we’ve been using to code everyday years before AI came around, like:

• Go to Definition
• Find References
• Rename Symbol
• Type checking
• Error diagnostics
• Hover documentation

Rather than treating code as plain text, LSP exposes semantic information such as symbols, types, inheritance, and references.

Imagine asking:

“Where is UserRepository used?”

Without LSP, Claude performs a text search that may return:

• the definition
• dozens of call sites
• comments
• documentation
• test files
• unrelated string matches

Claude must read all of that before determining what actually matters.

With LSP, Claude asks the language server for the symbol’s references and receives only the precise locations where that symbol is used. Instead of searching text, it navigates your code semantically.

The difference becomes even more valuable in large repositories.

Enterprise projects often contain:

• thousands of files
• millions of lines of code
• hundreds of packages

Traditional searches repeatedly scan those files. Language servers already maintain indexes of definitions, references, implementations, and type information. Claude simply queries those indexes, making navigation faster and far more precise.

One of the most underrated advantages of LSP integration is token savings.

Every line of search output consumes tokens, increases latency, and costs money. Text searches often return much more information than Claude actually needs, including comments, documentation, duplicate references, and unrelated matches. Claude has to spend part of its context window filtering that noise.

LSP eliminates most of this overhead. Instead of returning pages of search results, it provides only the relevant semantic information, such as:

• the symbol definition
• exact references
• implementation hierarchy
• type information

In large codebases with heavily referenced symbols, LSP-driven navigation can produce tool outputs that are 2–3× smaller than equivalent text searches.

That means:

• lower API costs
• faster responses
• less wasted context
• more room for Claude to reason about your code

LSP also makes refactoring much safer.

Suppose you rename a class called PaymentProcessor.

A simple text replacement could accidentally modify comments, documentation, string literals, or unrelated variables. A language server understands symbols rather than text, allowing Claude to rename only the actual class and its legitimate references.

Another major advantage is immediate diagnostics.

After Claude edits a file, the language server can instantly report:

• syntax errors
• missing imports
• unresolved identifiers
• type mismatches

Instead of waiting for a build or CI pipeline to fail, Claude can identify and fix problems immediately.

Sometimes people confuse LSP with the Model Context Protocol (MCP), but they complement each other rather than compete.

• LSP helps Claude understand your source code.
• MCP helps Claude interact with external tools such as GitHub, Slack, databases, and cloud services.

Together they allow Claude to understand both your application and the ecosystem around it.

LSP shifts Claude from simply reading code to actually understanding it. Rather than treating a repository as a collection of files, Claude reasons about symbols, relationships, types, and program structure.

The result is:

• faster navigation
• safer edits
• better refactoring
• immediate feedback
• lower token usage

LSP integration may not be as flashy as autonomous agents, but as a developer working on real-world codebases, it’s one of the most meaningful ways to level up your Claude Code workflow.