Tari Ibaba

It was only a matter of time.

This new local model is sending shockwaves across the entire AI ecosystem.

The new Qwen 3.8 27b model just shattered the boundaries of everything we thought was possible with local AI models.

A model that’s small enough to run on a local Macbook for FREE — yet matching up amazingly with supercomputer-powered models like Claude Opus 4.6 Max.

You can power Claude Code and all your agentic tools at zero cost.

A local model is now beating all these recently released top-tier models that run in the most powerful data centers in the world:

Qwen3.8-27B delivers frontier-level agent performance at a fraction of the size, scoring 61.7% on SWE-bench Pro and 84.3% on OSWorld-Verified versus Claude Opus 4.6 Max’s reported 53.4% and 72.7%, while also surpassing Qwen3.7-Plus (57.6% and 73.3%) on key agentic benchmarks

It’s really exciting to see where the AI landscape is heading — we’ve seen open-source models catch up with closed-source models — now we are starting to see local models start to give major competition to cloud-hosted models.

This is by far the most efficient AI model ever created — we’ve never seen this level of intelligence from a model this tiny.

At 27 billion parameters, Qwen3.8-27B can be compressed to roughly 16–19GB with GGUF quantization — putting it within reach of high-end consumer GPUs like the NVIDIA RTX 4090 and 5090, as well as Apple Silicon Macs with enough unified memory.

The improvements are unbelievable in coding and autonomous agent tasks.

Qwen3.8-27B scores 61.7% on SWE-bench Pro, up from 53.5% for Qwen3.6-27B and ahead of Qwen3.7-Plus at 57.6%. On DeepSWE 1.1, the jump is even larger: 42.2 versus 13.3 for its predecessor.

Computer use is equally impressive.

Qwen reports 84.3% on OSWorld-Verified and 81.9% on AndroidWorld, benchmarks that test whether AI agents can visually understand and operate desktop and mobile interfaces.

Qwen3.8-27B is built from the ground up to see an interface, reason about what to do, use tools, write software and execute long sequences of actions.

And does all of this with breathtaking speed — thanks to its unusual hybrid architecture, which combines something called Gated DeltaNet with conventional Gated Attention.

Normally, AI models get super slow and laggy when you feed them long documents or big files — because the their transformer algorithm usually forces them to re-read and compare every single word to every other word.

Qwen 3.8 fixes this slowdown by using a smart 3-to-1 tag-team system across its 64 layers:

• 3 Fast-Skimmer Layers (DeltaNet): These three layers zip straight through long lines of text at high speed, saving a ton of computer memory.
• 1 Deep-Thinking Layer (Standard Attention): The fourth layer steps in to double-check the details, making sure the AI still understands exact meanings and relationships between words.

This makes it way more efficient at processing massive amounts of text — which invaluable for the 1 million token context window support that it has.

It also optimizes its speed with Multi-Token Prediction (MTP) — which lets it predict and verify multiple tokens at once rather than generating everything strictly one token at a time.

Qwen 3.8 also gives you granular control over reasoning.

You can adjust reasoning_effort between xhigh, medium and low — or disable extended thinking entirely using enable_thinking.

So you can low reasoning for simple operations, then switch to xhigh when debugging something difficult — or disable thinking altogether when maximum speed matters.

Qwen3.8 also supports preserve_thinking — which lets its reasoning state persist across multi-turn conversations.

For long-running agents, this massively reduces redundant reasoning and improves KV-cache utilization — instead of repeatedly reconsidering the same information.

That level of sophistication in runtime reasoning control is highly unusual among open models — especially for its incredibly lean size.

Qwen3.8-27B is also a native vision-language model — capable of understanding text, images and video.

It scores 91.1% on OmniDocBench 1.5, demonstrating strong performance on complex documents, while its vision system can handle charts, STEM diagrams, screenshots and other visual information.

Qwen also supports hour-scale video understanding, with configurable frame sampling allowing developers to balance detail against computational requirements.

Put everything together and the significance becomes clearer.

A 27 billion parameter model can now rapidly write and debug software, operate computer interfaces, analyze documents, understand images and video, reason autonomously, maintain thinking state and process enormous contexts—all on hardware you can own.

We can clearly see where all this is heading — frontier-class capabilities are beginning to escape the datacenter.

Wow this is huge.

Elon Musk’s xAI just released a brilliant new coding agent with unbelievable new features — and the developer community has been going absolutely wild.

Grok Build is here to unleashed the full power of the most advanced Grok models in every software development task imaginable.

With a new goal-centric plan mode and headless automation mode

And these are just a few of everything this new Grok Build brings to the table.

Sub-agents working in parallel in Grok Build:

Let’s take a look at 5 of these features and the massive benefits they provide in our development workflows.

1. Industry-leading 2 million token context window

Context is still biggest limitations of current coding agents.

Large projects often contain huge codebases, extensive documentation, configuration files, and dependency trees that exceed what most AI models can effectively keep in memory.

Grok Build is powered by top-tier Grok models like Grok 4.20, which features a 2 million token context window, let’s us give it:

• Entire codebases
• Large documentation sets
• Technical specifications
• Dependency chains
• Historical implementation notes

all within a single session.

Instead of constantly re-explaining project structure, the model can maintain a much deeper understanding of the system it is working on.

2. Headless automation mode

Headless automation will completely transform how you approach development.

Instead of requiring an interactive terminal session, Grok Build can run inside:

• CI/CD pipelines
• Cron jobs
• Automation scripts
• Build systems

This allows engineering teams to automate routine development work.

For example, Grok Build could:

• Review pull requests overnight
• Refactor legacy code
• Update documentation
• Identify technical debt
• Perform maintenance tasks

without requiring a developer to actively supervise every step.

3. Plan mode lets you see everything

One of the biggest frustrations with autonomous coding agents is that they can spend twenty minutes modifying files before you realize they misunderstood the task.

Grok Build introduces a structured Plan Mode to solve this problem.

Before editing a single file, the agent generates a detailed execution plan showing:

• Which files will be modified
• The implementation steps
• Dependencies between tasks
• Areas of potential risk

Developers can review the plan, rewrite steps, leave comments, or approve it entirely.

Only after approval does Grok Build begin making changes, which are then presented as clean Git diffs.

So we end up with workflow that keeps humans in control while still benefiting from automation.

4. Parallel subagents and Git worktrees

Complex features often require changes across multiple parts of a project.

Rather than handling everything sequentially, Grok Build can split a large task into smaller pieces and launch up to eight specialized subagents to work simultaneously.

To avoid conflicts, each subagent operates inside its own Git worktree and branch.

This provides several advantages:

• Faster execution through parallel work
• Isolation between agent tasks
• Fewer merge conflicts
• Easier review and validation

Instead of multiple agents fighting over the same files, each works independently before the final results are merged together.

5. Works with all the tools you already use

Your skills, your hooks, your AGENTS.md, your plugins, everything.

MCP

Grok Build supports Anthropic’s Model Context Protocol out of the box.

This allows teams to connect the agent directly to:

• Internal APIs
• Proprietary databases
• Documentation systems
• Custom tools and workflows

Rather than forcing organizations to change their infrastructure, Grok Build can plug into what already exists.

ACP (Agent Communication Protocol)

It also supports Agent Communication Protocol (ACP).

ACP enables external tools and IDEs to communicate directly with the agent environment, making integrations with platforms like VS Code, Cursor, JetBrains, and custom developer tools significantly easier.

What makes Grok Build interesting isn’t any single feature — it’s how these features work together.

The massive context window helps the agent understand entire systems. Plan Mode adds transparency and control. Parallel subagents accelerate execution. MCP and ACP provide extensibility. Headless mode enables automation beyond the desktop.

Together, they push AI beyond simple code generation and toward something much closer to a true software engineering agent.

DeepSeek just released a revolutionary new open-source Claude Code competitor — but it’s so much more than that.

The new DeepSeek Harness is not just trying to be a coding agent.

It’s not even trying to compete in models or features or settings or commands.

It’s trying to compete at the AI operating system layer — the harness layer.

It’s the harness layer that really makes AI coding possible — the layer that transforms any model into an autonomous agent.

AI models on their own are very intelligent but can only chat — they need a high-quality harness to let them read files and make network requests and extend themselves with plugins and skills — like what an Operating System does for a very powerful processor.

So DeepSeek Harness is trying to be the most powerful operating system ever made — that maximizes any model to its full intelligence potential to give you the best and fastest results possible.

It’s unbelievably flexible — you can basically replace or customize every single thing.

Tools like Claude Code and Cursor let you swap models and add new extensions.

But DeepSeek Harness goes much much further — everything is a plugin — everything:

• Model adapters
• Permission systems
• Session storage
• File-system access
• Tool definitions
• Agent orchestration logic
• Even the agent execution loop itself

List of connected plugins in a DeepSeek Harness:

You are not locked into a predefined way of building agents — you can even connect it with other harnesses like Claude Code.

You can assemble your own agent stack from interchangeable components — we’ve had tech stacks, now we have agent stacks in 2026.

You can even embed an entire agent system inside a larger workflow — Agent-in-Agent Orchestration.

For example a DeepSeek Harness workflow could:

• Use Claude Code for software development
• Call OpenAI Codex for specific coding tasks
• Route research to another agent
• Coordinate everything through a parent orchestrator

And the harness itself is not limited to DeepSeek models.

It supports OpenAI-compatible API endpoints — which allows you to mix and match models across providers.

So like for example:

• DeepSeek for reasoning
• A vision model for image analysis
• Claude for writing
• Local open-source models for privacy-sensitive tasks

The framework focuses on orchestration rather than locking users into a single model ecosystem.

Four purpose-built runtime modes

Instead of changing model intelligence, DeepSeek Harness changes the environment around the model.

Standard mode

General-purpose execution for everyday workflows.

Code mode

Optimized for long-running software engineering tasks, including:

• Planning
• Coding
• Debugging
• Testing
• Multi-step implementation

Minimal mode

A lightweight, sandboxed environment designed for benchmarking and evaluations such as:

• SWE-bench
• TerminalBench
• Research experiments

Creator mode

Perhaps the most experimental runtime.

Creator Mode allows agents to:

• Inspect plugins
• Modify plugins
• Compose new plugins
• Reconfigure parts of their own environment

Rather than simply using tools, agents can actively reshape the harness itself.

State-of-the-art generative UI

DeepSeek Harness also includes dsh-genui, a system for generating interactive user interfaces.

Instead of responding only with text or Markdown, agents can render:

• Graphs
• Dashboards
• Visualizations
• Interactive widgets
• Sandboxed mini-applications

This allows agents to present information through purpose-built interfaces rather than lengthy text outputs.

Unprecedented transparency

A major focus of DeepSeek Harness is visibility.

The framework ships with a local web interface that exposes operational details often hidden in other agent systems.

Live operational metrics

Developers can monitor:

• Token usage
• Tokens per second
• Tool calls
• Step counts
• Total turns
• Prompt cache hit rates

All metrics are available in real time.

Interactive trajectory timelines

The UI also provides a detailed audit trail showing:

• Every reasoning step
• Tool inputs and outputs
• Sub-agent activity
• Execution latency
• Context assembly details

This makes debugging, optimization, and governance significantly easier.

Built for long-running, low-cost agents

Long-running agent workflows are typically expensive because context grows over time.

DeepSeek Harness tackles this through:

• Optimization around DeepSeek V4-Flash
• Aggressive prompt caching

In extended sessions, cache hit rates reportedly reach as high as 95–100%. As a result, large portions of prompts and conversation history can be reused instead of being repeatedly processed.

What this means is huge as a developer:

• Multi-hour coding agents become affordable
• Multi-agent systems can run continuously
• Complex workflows incur far lower costs
• Long context histories become less expensive to maintain

DeepSeek Harness is not trying to be just another AI agent framework.

It is attempting to become a flexible orchestration layer for the entire agent ecosystem, with key innovations like:

• A true “everything is a plugin” architecture
• Agent-in-agent orchestration
• Model-agnostic composability
• Four specialized runtime modes
• Native generative UI support
• Deep operational transparency
• Extremely cost-efficient long-running execution

As AI systems become more complex and multi-agent workflows become more common, orchestration is starting to matter as much as model intelligence itself.

DeepSeek Harness is one of the strongest signals so far that the future of AI infrastructure will be built around composable systems, not just increasingly powerful models.

GLM-5.3 is a very unconventional upgrade — no one should ignore this and what it means.

Z.ai (the makers) refused to follow the same old formula of training a bigger model and spending more and more on compute.

Like as far as weights and parameters go, this is the exact same model as GLM-5.2 (and still open-source btw).

But somehow it’s just better in every single way — with an unbelievable 50% performance leap and scary coding and hacking ability that now surpasses even Claude Mythos 5.

GLM-5.3 beats every single model in the official Terminal-Bench 2.1 benchmark — include Fable 5 — despite being several times cheaper:

On DeepSWE, GLM-5.3 scored 66.9, nearly matching Kimi K3 (67.5) and outperforming GLM-5.2 (46.2), while remaining competitive with Fable 5 (69.7) and GPT-5.6 Sol (72.7).

They didn’t build a new model from scratch — they focused entirely on how to make the model learn better from existing data — using sophisticated techniques like reinforcement learning and environment scaling.

A novel approach that has now paid off massively.

Open-source GLM-5.3 goes toe-to-toe with Fable 5 in coding and every other area — despite being several times cheaper:

On Agents’ Last Exam (CLI), GLM-5.3 posted the highest score at 28.5, narrowly surpassing GPT-5.6 Sol (28.6) and Kimi K3 (27.6) to lead the benchmark.

It’s challenging the long-standing believe that better AI performance needs larger base models.

From GLM-5.3 we are seeing that we can get serious results from simply coming with new ways to improve how models learn after pre-training.

We could see major gains across board as more and more AI companies consider this different approach.

The cybersecurity performance is incredible.

GLM-5.3 achieved 84.5% on the CyberGym benchmark, a test designed to evaluate vulnerability discovery, software security analysis, and exploit-chain reasoning, surpassing both Claude Mythos 5 and GPT-5.6 Sol on the benchmark.

It’s very strong at:

• Vulnerability discovery
• Security auditing
• Root-cause analysis
• Multi-step software reasoning

GLM-powered systems identified thousands of real-world software vulnerabilities during internal testing, including critical security flaws in widely used developer tools.

They also designed GLM-5.3 with autonomous agents in mind.

The model supports:

• 1 million token context
• 128,000 token output length

This allows it to work across large codebases, lengthy technical documents, and multi-stage workflows without losing context.

Just as important, it also completes tasks using much fewer output tokens than GLM-5.2 while achieving higher accuracy.

That combination means:

• Lower inference costs
• Faster execution
• Better agent efficiency
• Improved performance on long-running tasks

And as we find ourselves using AI more and more for software engineering, efficiency is becoming just as important as raw intelligence.

GLM-5.3 also changes how reasoning works.

You can turn off reasoning anymore like in some other models — you can only choose between Low, High, and Max.

This reflects a growing industry trend where reasoning is treated as a core capability rather than an optional feature.

The question is no longer whether the model should think, but how much compute should be allocated to solving a problem.

Z.ai also remains committed to releasing model weights publicly.

But because of GLM-5.3’s strong cybersecurity abilities, they’ve had to introduce a new Open Source Shield Initiative — which is meant to:

• Keep defensive security research open
• Support code auditing and vulnerability detection
• Restrict access to high-risk offensive exploitation capabilities

This helps to balance openness with responsible deployment.

GLM-5.3 may ultimately be remembered less for its benchmark scores and more for what it represents.

It shows us that massive gains are still possible without training a new base model.

It sets a new bar for AI-driven cybersecurity research. And it is optimized for the future of long-horizon autonomous agents.

If earlier AI progress was defined by scaling pretraining, GLM-5.3 is showing us that next era could be all about scaling post-training instead.

This Claude Code command is amazing.

It’s somehow like the multi-agent teams feature — but much simpler and more straightforward.

It’s perfect for those large-scale changes that can easily be broken down into smaller tasks — like mass refactoring and codebase migration.

It spins up multiple AI agents to work simultaneously across the codebase — giving you an immense boost in productivity.

Let’s look at the key features that make it so invaluable when working with Claude Code — from autonomous testing and pull requests, to how it combines brilliantly with other Claude Code commands to build a comprehensive engineering workflow.

1. Multi-agent task decomposition

The foundation of /batch is its ability to break large requests into smaller, independent units of work.

When you invoke /batch, Claude Code:

• Analyzes the repository.
• Understands the requested objective.
• Identifies logical boundaries within the codebase.
• Decomposes the work into 5–30 independent work units.

Rather than editing files sequentially, Claude distributes work across multiple agents that can operate in parallel.

For example, a framework migration might be divided into:

• Shared UI components
• Authentication modules
• Routing logic
• API integrations
• Testing infrastructure

By separating work into distinct scopes, /batch can scale far beyond the limitations of a traditional single-agent workflow.

2. The /batch and /simplify power combo

One of the more interesting aspects of /batch is how it complements Claude Code’s /simplify command.

While /simplify focuses on reducing complexity and unnecessary abstractions, /batch can coordinate improvements across an entire codebase.

The combination gives us several advantages:

• Identifies overly complex patterns at scale.
• Reduces unnecessary abstractions and indirection.
• Improves code readability and maintainability.
• Creates greater consistency across modules.
• Eliminates repetitive manual refactoring work.

Instead of simplifying files one by one, you can use /batch to coordinate the effort across dozens of components simultaneously. This makes large-scale codebase cleanup and standardization significantly faster and more manageable.

3. Git worktree isolation

A key feature of /batch is its use of Git worktrees.

Every subagent receives its own isolated worktree instead of sharing a single working directory.

This enables:

• Concurrent development
• Independent validation
• Isolated dependency management
• Reduced merge conflicts

Because each worker operates in its own environment, changes made by one agent do not interfere with another.

A component migration can run in one worktree while another agent updates tests or refactors utilities elsewhere in the repository.

This isolation is what makes large-scale parallel execution practical and reliable.

4. Autonomous testing and pull requests

/batch is more than a code-editing tool.

Each subagent behaves like an autonomous developer responsible for its assigned scope.

Subagents can:

• Implement code changes
• Run test suites
• Detect failures
• Fix localized issues
• Validate completed work
• Create commits or pull requests

Instead of producing one massive repository-wide change, /batch generates smaller, self-contained outputs that are easier to review and merge.

The result is less manual coordination and a cleaner development workflow.

5. Plan-first execution

Before making any changes, /batch generates a structured execution plan.

The plan outlines:

• How the task was divided
• Which files or directories belong to each work unit
• The responsibilities assigned to each subagent
• The proposed transformation for each area of the codebase

Developers review and approve the plan before execution begins.

This approval stage:

• Provides visibility into the process
• Prevents unexpected repository-wide changes
• Keeps humans in control of major modifications

Rather than blindly applying edits, /batch follows a plan-first approach designed for large-scale engineering work.

Final thoughts

Claude Code’s /batch command represents the broader shift single-agent coding assistance to coordinated multi-agent software engineering.

With key features like:

• Intelligent task decomposition
• Parallel AI execution
• Git worktree isolation
• Autonomous testing
• Pull request generation
• Human approval checkpoints

It enables repository-wide transformations at a scale that would traditionally require significant manual effort.

Software is no longer being built by a single AI agent, but now by a coordinated systems of specialized agents working together toward a common objective.

This is HUGE.

Google’s new Gemini 3.7 Flash is absolutely insane.

It even dominated Claude Sonnet 5 and GPT-5.6 Terra — it’s the best & fastest mid-tier coding model in the world right now.

It literally jumped 11 good places in the AI Arena Leaderboard — now even beating models like Opus 4.8 and Grok 4.5 — despite being several times cheaper and faster.

It’s so amazing at software engineering, web design, and UI generation.

Gemini 3.7 Flash achieved 65.3% on DeepSWE v1.1—up dramatically from Gemini 3.6 Flash’s 48.6% and ahead of Claude Sonnet 5’s 49.7% and GPT-5.6 Terra’s roughly 52–54% results on the same benchmark, establishing a new high-water mark for autonomous software engineering.

Gemini 3.7 Flash has by far the best Time per Intelligence of any model of this intelligence level:

Google’s Gemini 3.7 Flash delivers a breakthrough intelligence-to-speed ratio, hitting a peak output speed of roughly 340 tokens per second while scoring 56 on the Artificial Analysis Intelligence Index—outperforming several pricier flagship peers while finishing multi-step workflows up to 40% faster

It costs so much less than all these other models on the same level of intelligence — you won’t believe how cheap it is right now.

Gemini 3.7 Flash has by far the best Cost per Intelligence of any model of this intelligence level:

Smarter agentic planning — “diligent” thinking

The reasoning and planning have gotten so much more sophisticated.

Instead of immediately generating a response, the model spends more time planning, reasoning, and coordinating tools before taking action.

It thinks more diligently, putting in more effort into multi-step planning and tool calls. A more disciplined execution means less manual oversight and fewer retries across engineering workflows.
— Google

This gives you:

• Better upfront planning for complex tasks
• Self-correction when code or tool calls fail
• Recovery from dead ends without getting stuck in retry loops
• Stronger tool orchestration across multi-step workflows
• Intent clarification when instructions are ambiguous

It doesn’t make risky assumptions of things it’s not sure about — it pauses and ask the right question before continuing.

Which makes a much more reliable coding partner.

Massive software engineering gains

Nobody can look down on Gemini when it comes to coding anymore.

Gemini 3.7 Flash achieved 65.3% on DeepSWE v1.1—up dramatically from Gemini 3.6 Flash’s 48.6% and ahead of Claude Sonnet 5’s 49.7% and GPT-5.6 Terra’s roughly 52–54% results on the same benchmark, establishing a new high-water mark for autonomous software engineering.

3.7 Flash outperforms other frontier models like Sonnet 5 and GPT-5.6 Terra is key software engineering abilities — despite being multiple times cheaper.

It’s been such a massive upgrade:

Benchmark Performance:

65.3% on DeepSWE v1.1

• Up from 48.6% in Gemini 3.6 Flash
• Measures complex, long-horizon software engineering tasks

43.6% on FrontierCode 1.1

• Evaluates first-pass coding accuracy
• Tests real-world engineering capabilities

These gains translate into real meaningful improvements for you as a developer:

• Better understanding of large codebases
• Stronger debugging abilities
• More accurate feature implementation
• Improved multi-file reasoning
• Higher-quality code on the first attempt

Exceptional web dev & frontend design ability

Frontend generation is becoming one of the most competitive areas in AI — and Gemini 3.7 Flash is now among the strongest performers.

Gemini 3.7 Flash generating a world class landing page with posh visual effects from scratch:

Frontend Benchmarks:

• 1588 Elo on WebDev Arena
• 1588 Elo on Code Arena

These scores place Gemini 3.7 Flash ahead of competing models like Claude Sonnet 5 and GPT-5.6 Terra in frontend and full-stack application generation.

And these benchmarks evaluate more than visual appearance. High-performing models must create:

• Responsive layouts
• Multi-component interfaces
• Consistent design systems
• Functional application logic
• Production-quality user experiences

As someone building real-world products, this means fewer revisions and better results for you from the very first prompt.

Incredible UI generation ability

You can give it:

• Wireframes
• Screenshots
• Design systems
• Existing interfaces
• Product mockups

The model can then generate functional applications that closely match the provided designs.

Instead of hallucinating generic layouts, it is far better at preserving structure, styling, and user experience patterns.

The result:

• Fewer prompts
• Less back-and-forth
• Faster prototyping
• Quicker path to production-ready applications

Industry-leading Pricing

This is hands-down one of the biggest selling points.

Introductory Pricing (through December 31, 2026)

• $0.75 per million input tokens
• $3.75 per million output tokens

Standard Pricing (starting January 1, 2027)

• $1.50 per million input tokens
• $7.50 per million output tokens

Even at standard pricing, Gemini 3.7 Flash remains highly competitive.

At launch pricing, it is:

• More than 60% cheaper than Claude Sonnet 5
• More than 60% cheaper than GPT-5.6 Terra
• Competitive or superior across several coding and web development benchmarks

This combination of performance and affordability makes it one of the strongest value propositions in the AI market today.

Far more than just a routine upgrade

It gives us major advances in:

• Agentic planning
• Self-correction
• Software engineering
• Web development
• Frontend design

Combined with aggressive pricing, Gemini 3.7 Flash sets a new benchmark for cost-efficient AI.

For developers and startups building AI-powered products, it’s one of the most compelling models available today.

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 new AI design tool from Anthropic is sending shockwaves across the entire web design industry.

Claude Design is well and truly here — with so many features that completely eliminate the need and cost of hiring a web designer in the vast majority of cases.

And it’s far more advanced that those one-time design generators — this is a full-blown collaborative design environment that helps you discover, refine, compare, and implement ideas faster than ever before.

Generating a UI with dynamically generated controls using Claude Design:

And it works hand-in-hand with Claude Code — you can go from idea to design to full working code in no time at all.

Sophisticated dynamic tweaks panels

This is hands-down one of the most incredible features.

When Claude creates a design, it can automatically create visual controls tailored to that specific interface.

These controls can include:

• Sliders
• Toggles
• Color palettes
• Spacing controls
• Typography adjustments
• Density settings
• Layout controls

The generated design has its own custom tweaks that let you adjust the theme and typography:

Instead of typing:

“Reduce the padding by 20%.”

or

“Make the design feel more compact.”

You can adjust settings directly on the canvas and see changes instantly.

This instantly gives you:

• Faster iteration
• Fewer prompt cycles
• Less token usage
• More precise visual control

The experience feels closer to using professional design software than just chatting with an AI.

Guided design questionnaires

A major challenge with AI design tools is knowing what prompt to write.

Claude Design addresses this with guided questionnaires and visual discovery exercises.

Rather than presenting a blank canvas, it asks users questions like:

• What are you building?
• Who is the audience?
• What style do you prefer?
• Which layouts appeal to you?
• What is the primary goal of the experience?

The platform can also present visual options and taste tests to help users identify preferences before design generation begins.

This approach offers several advantages:

• Reduces prompt anxiety
• Helps users clarify their vision
• Produces more relevant designs
• Makes design accessible to non-designers

Instead of guessing what to ask for, users are guided toward a solution.

Multi-option brainstorming

Traditional design workflows often focus on a single concept at a time.

Claude Design encourages broader exploration.

Rather than generating one design, it can produce multiple radically different approaches simultaneously.

For example, a landing page request might generate:

• A minimalist concept
• A bold marketing-focused layout
• A highly visual creative direction
• A data-heavy enterprise design

All options appear side-by-side on the same canvas.

This makes it easier to:

• Compare ideas
• Identify strengths and weaknesses
• Gather stakeholder feedback
• Combine the best elements into a final concept

Instead of asking for version after version, teams can evaluate several directions immediately.

Direct design-system syncing

Many AI-generated interfaces look impressive but are disconnected from real products.

Claude Design attempts to solve this through /design-sync.

/design-sync lets Claude connect to:

• GitHub repositories
• Storybook libraries
• Existing applications
• Internal design systems

Once connected, Claude can use:

• Real React components
• Company color palettes
• Existing typography systems
• Approved design patterns
• Spacing and layout rules

This means prototypes are built using actual product assets rather than generic SaaS templates.

So you end up getting:

• Better brand consistency
• More realistic prototypes
• Less redesign work
• Faster implementation

Interactive canvas controls

Claude Design is not limited to text chat.

You can interact directly with designs through the canvas itself.

Capabilities include:

• Pin-comments on individual elements
• Drag-and-drop adjustments
• Visual alignment changes
• Layout refinements
• Direct element manipulation

This hybrid workflow combines AI generation with traditional design interactions.

Not every design change should require a prompt.

Sometimes it is faster to simply move an element.

Claude Design supports both approaches.

Seamless handoff to Claude Code

The final stage of the workflow is where Claude Design becomes especially powerful.

Once a prototype is approved, Claude can package the project into a structured handoff bundle.

That bundle can flow directly into Claude Code or other AI-assisted development workflows.

This gives you a continuous pipeline:

Idea → Prototype → Refinement → Design-System Validation → Claude Code → Production Software

You end up getting:

• Reduced designer-developer handoff friction
• Less documentation overhead
• Faster implementation
• Better alignment between design and code

Instead of rebuilding requirements from screenshots or mockups, development can begin with the design context already intact.

Why it matters

Claude Design represents a shift from AI-generated mockups to AI-assisted product creation.

Its key differentiators include:

• Dynamic Tweaks panels
• Guided design interviews
• Multi-option brainstorming
• Design-system synchronization
• Interactive canvas controls
• Direct integration with Claude Code

Together these features help you and your team move from idea to implementation faster while maintaining consistency with existing products and design standards.

Rather than simply generating screens, Claude Design focuses on improving the entire journey from concept to production-ready software.

This is absolutely incredible.

Meta’s just released a revolutionary new AI coding agent.

The new Muse Code is so unbelievably cheap and intelligent — once again we see the clear trend of AI getting cheaper and cheaper.

And it comes with a revolutionary new approach to multi-agent collaboration, that could transform the workflow of so many developers.

Powered by their most powerful model ever — this is going to make major impact on the entire AI coding ecosystem.

Demo stage #1: A drone fly through video to be given to Muse Code to integrate into a landing page:

Muse Code is a terminal-based agent designed from the group up to handle complete software engineering tasks across large repositories — putting it directly against tools like Claude Code and Codex.

But it’s not just yet another coding assistant in your terminal.

Meta is building it around a bigger idea: coding agents should work for hours, coordinate multiple workers, survive failures, and keep making progress autonomously.

Let’s check out all the most amazing features it comes with — including how incredibly inexpensive it is.

Demo stage #2: Asking Muse Code to integrate the video into the website with various marketing copies at different points in the video — directly from the terminal:

1. Persistent background agents — less repeated work

Most coding agents create a subagent, give it a task, collect the result, and destroy it.

Muse Code instead keeps asynchronous background agents alive throughout the session.

They can:

• investigate different parts of the codebase
• retain context they’ve already gathered
• work while the main agent continues
• report useful discoveries back later

For us developers, this means less repeated exploration of large repositories.

Instead of one agent repeatedly searching hundreds of files, you get specialized workers that gradually build knowledge of the project while the main agent keeps coding.

Demo stage #3: Muse Code intelligently integrates the video into the website, with all the marketing copies and the final call to action:

2. Incredible low cost — run coding agents for a fraction of the price

Meta is also being extremely aggressive on price.

Its Contributor tier can bring pricing down to as little as $0.20 per million output tokens — less than one-tenth of typical frontier-model rates.

One thing you need to know though — if you’re using this discounted tier, you have to agree to let Meta use your interactions, including generated code, to help improve its models.

If you’re comfortable with that, this could be huge for your cost savings.

Long-running agents can burn through enormous numbers of tokens. Making those tokens dramatically cheaper makes Muse Code’s hours-long autonomous coding loops and parallel agents much more practical to run regularly.

3. Muse Spark 1.2 — Meta now has a serious coding model

Muse Code is powered by Muse Spark 1.2, Meta’s new coding-focused model.

And interestingly Meta says the model and coding harness were co-trained — not something you see everyday from most other models.

Rather than wrapping an agent around a generic model afterward, Meta trained Spark using the environment and workflows it would eventually operate inside.

Some key benchmark results from Muse Spark 1.2:

• Terminal-Bench 2.1: 82.9%
• DeepSWE 1.1: 59.3%
• Meta Internal Coding Bench: 70.6%

Meta hasn’t taken the coding crown (yet??) — but it’s clearly become a serious competitor.

4. Parallel worktrees — build multiple things at once

Muse Code can also fan large tasks out across multiple subagents running simultaneously in isolated Git worktrees.

Each agent gets its own workspace, allowing several agents to modify the same repository without constantly overwriting each other’s work.

Meta demonstrated this by having Muse Code build six game features simultaneously without collisions.

The practical benefit is speed.

Instead of:

feature A → feature B → feature C → feature D

you potentially get:

feature A + feature B + feature C + feature D

all being developed simultaneously.

AI coding starts looking less like one extremely fast developer and more like a small engineering team working in parallel.

5. Crash recovery — long-running agents don’t lose everything

Long-running agents create another problem: failure becomes increasingly expensive.

Imagine an agent researching, coding, testing, and debugging for three hours — then the process crashes.

Muse Code addresses this with a local append-only event log.

Model calls, tool executions, approvals, edits, and other actions are recorded as events. The runtime can replay them to reconstruct its previous state.

That makes executions restart-safe.

For five-minute coding prompts, this isn’t particularly important.

For autonomous tasks lasting several hours, it’s essential.

6. 24-hour coding runs — AI coding becomes a background process

Meta is clearly designing Muse Code for much longer tasks than normal prompt-and-response coding.

In one experiment, Muse Code optimized GPU kernels for NVIDIA Hopper hardware.

The agent repeatedly:

wrote code → compiled → profiled → analyzed → improved

It made more than 1,000 tool calls across runs lasting up to 24 hours.

That’s a very different model of AI-assisted development.

For optimization, migrations, debugging, test improvement, and other measurable engineering problems, you could define the goal, leave the agent running, and return later to the results.

What all this tells us

The most interesting part of Muse Code isn’t another benchmark score.

It’s everything surrounding the model:

Persistent agents. Parallel worktrees. Crash recovery. Thousands of tool calls. 24-hour autonomous runs.

The AI coding race is moving beyond “which model writes the best code?”

It’s increasingly about which system can reliably keep working until the engineering task is actually finished.

Muse Code is Meta’s answer.

This new viral Skill is an absolute game changer for Claude Code.

The I Have ADHD Skill massively upgrades the quality and clarity of Claude’s responses by encouraging it to communicate in a much more direct, structured, and action-oriented way.

It removes all the fluff and goes straight to the point — saving you so much token costs and improving your mental model of the task at hand.

The crucial problem it’s here to solve

AI coding assistants often answer simple questions with long explanations before getting to the solution.

That style can be useful for learning — but when you’re debugging, shipping features, or reviewing code, it creates unnecessary friction.

The “I Have ADHD” skill solves that by encouraging Claude to prioritize the next action instead of lengthy context.

How the Skill works

The skill dramatically changes how Claude structures its responses.

Instead of long introductions, it’s encouraged to:

• Start with the immediate next step.
• Break work into numbered tasks.
• Remove unnecessary filler.
• Show progress throughout a task.
• Finish with one clear next action.

You end up getting an AI that isn’t just intelligent, but also extremely easy to work with.

Why so many developers love it

The project quickly gained over 10,000 stars on GitHub within days of launch.

Because it addresses a frustration many developers have long had with AI assistants: too much explanation and not enough execution.

Whether you’re debugging, refactoring, or navigating a new codebase, concise responses reduce cognitive load and help you stay focused.

How to get started with the I Have ADHD skill

Install it easily with these commands:

Then type /i-have-adhd in a Claude Code session to activate it — all the responses will be structured according to the rules of the skill for the rest of the session:

How to use it to transform your workflow (5 practical use cases)

1. Debugging production issues

Without the skill

With the skill

Why it matters: When production is down, you need the next action — not a lesson.

2. Refactoring legacy code

Without the skill

With the skill

Why it matters: Breaking work into milestones makes large refactors feel manageable.

3. Building large features

Without the skill

With the skill

Why it matters: You stay focused on one phase instead of being overwhelmed by the entire implementation.

4. Learning an unfamiliar codebase

Without the skill

With the skill

Read these first:

Why it matters: You can understand the project faster by focusing only on the files that matter.

5. Reviewing pull requests

Without the skill

With the skill

Why it matters: Prioritized feedback makes reviews quicker to understand and easier to act on.

Final thoughts

You don’t just need a smarter assistant — you need an assistant that helps you get things done faster.

Sometimes the biggest productivity improvement isn’t giving an AI more knowledge. It’s simply teaching it to get to the point.