<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: ail akram</title>
    <description>The latest articles on DEV Community by ail akram (@ail_akram_dcc5063c428734b).</description>
    <link>https://dev.to/ail_akram_dcc5063c428734b</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3993672%2F8fe1cc41-9900-4eb9-a9ae-9350e429b7bd.png</url>
      <title>DEV Community: ail akram</title>
      <link>https://dev.to/ail_akram_dcc5063c428734b</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/ail_akram_dcc5063c428734b"/>
    <language>en</language>
    <item>
      <title>AI Agent Infrastructure: A Beginner's Guide to the Stack, Tools, and Architecture Behind Autonomous Agents</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Mon, 16 Nov 2026 15:41:15 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/ai-agent-infrastructure-a-beginners-guide-to-the-stack-tools-and-architecture-behind-autonomous-23l</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/ai-agent-infrastructure-a-beginners-guide-to-the-stack-tools-and-architecture-behind-autonomous-23l</guid>
      <description>&lt;p&gt;HustleToAI | Beginner-friendly guide | Research and fact-check cut-off: November 16, 2026&lt;/p&gt;

&lt;p&gt;AI agent infrastructure is everything that sits around an AI model so it can do real work: the tools it calls, the memory it keeps, the system that coordinates its steps, and the controls that stop it from breaking things. A chatbot answers. An agent acts. That gap is why agents need their own plumbing, and this guide walks you through it in plain English, with a starter stack near the end.&lt;br&gt;
What Is AI Agent Infrastructure (and Why Does It Matter)?&lt;br&gt;
Think of an AI model as an engine. The infrastructure is the rest of the car. Without it, you have a loud thing sitting on a workbench.&lt;br&gt;
AI Agents vs. Chatbots vs. Generative AI: The Key Differences&lt;br&gt;
Generative AI makes content, like text, images, or code. A chatbot wraps a conversation around it: you ask, it answers, done. An agent takes a goal, breaks it into steps, uses tools, checks the result, and keeps going until it finishes or gets stuck.&lt;br&gt;
Ask a chatbot how to book a flight and you get instructions. Ask an agent and it books the flight, if you've given it permission to.&lt;br&gt;
Why Agents Need Their Own Infrastructure&lt;br&gt;
A normal app does the same thing every time. An agent decides what to do next, and it might decide differently on Tuesday than it did on Monday. So you need ways to limit what it can touch, remember what it did, and see why it did it. Regular app hosting doesn't give you that.&lt;br&gt;
Illustrative scenario: Imagine an agent asked to organize a support inbox. If its permissions are too broad, it might archive or forward messages when it was only supposed to summarize them. This is a hypothetical example, not a report of a real incident. It shows why tool permissions, approval steps, and activity logs matter.&lt;br&gt;
Who Needs to Understand This (Developers, IT Teams, Business Leaders)&lt;br&gt;
Developers build agents. IT teams decide what access those agents get. Business leaders pay for them and own the risk. If you're signing off on an agent that can touch customer data, you should know what's underneath it.&lt;br&gt;
The Core Layers of an AI Agent Infrastructure Stack&lt;br&gt;
Names vary from article to article, but most stacks have the same five layers.&lt;br&gt;
Model Layer: The "Brain" (LLMs and Reasoning)&lt;br&gt;
The large language model handles reasoning and decision-making. Common options include Claude, GPT, Gemini, Llama, and Mistral. Choose a model based on the complexity of the task, response quality, speed, and cost. A simple information lookup may not need an expensive reasoning model. Before estimating your operating budget, check the provider's current API pricing because input tokens, output tokens, caching, and additional features can have different charges.&lt;br&gt;
Tools Layer: How Agents Take Action (APIs, Browsers, Code Execution)&lt;br&gt;
Tools are how an agent touches the outside world: an API, a browser, a code runner, a database. Without tools, an agent can only talk. With them, it can file a ticket, read a spreadsheet, or restart a server.&lt;br&gt;
Data and Memory Layer: Short-Term, Long-Term, and Vector Storage&lt;br&gt;
Short-term memory is the conversation so far, held in the model's context window. Long-term memory lives outside the model, often in a vector database that finds information by meaning instead of exact words. That's how an agent can recall last week's customer issue. The pattern is called retrieval-augmented generation, or RAG.&lt;br&gt;
Orchestration Layer: Coordinating Steps, Agents, and Workflows&lt;br&gt;
The orchestrator decides what happens next: call this tool, wait for that result, retry, hand off to another agent. LangGraph, LlamaIndex, and the OpenAI Agents SDK are common options. It's the project manager. It doesn't do the work, it makes sure the work happens in the right order.&lt;br&gt;
Observability and Governance Layer: Monitoring What Agents Do&lt;br&gt;
You want a log of every step: what the agent saw, what it decided, what it called. Tools like Langfuse, LangSmith, and OpenTelemetry-based setups handle this. Governance sits on top, with rules about who approved what. Without this layer you can't explain a mistake afterward, which gets awkward fast.&lt;br&gt;
Types of AI Agents and Where Each Fits in Your Infrastructure&lt;br&gt;
The textbook list of agent types sounds abstract. It comes from Russell and Norvig's AI textbook, and here's what it means in practice.&lt;br&gt;
Reactive and Task-Specific Agents&lt;br&gt;
These respond to an input with no memory of the past. A spam filter is one. They're fast, cheap, and predictable, which makes them a good fit when the job is narrow and the rules are clear.&lt;br&gt;
Stateful, Model-Based, and Goal-Based Agents&lt;br&gt;
These remember what's happened and work toward an outcome. A support agent that knows you already tried restarting your router is stateful. A goal-based agent picks its actions to reach something specific, like "resolve this ticket."&lt;br&gt;
Planning and Learning Agents&lt;br&gt;
Planning agents organize actions into steps before or during execution. Learning agents use experience or feedback to modify their future behavior. These are different capabilities: an agent can plan without learning, and an agent can learn without following a fixed planning process. In production systems, feedback-based improvements may involve updating memory, refining instructions, or retraining a model. These approaches should not be treated as interchangeable.&lt;br&gt;
Multi-Agent Systems: When One Agent Isn't Enough&lt;br&gt;
Several agents, each with one job: one researches, one writes, one reviews. That helps when a task is too big for one context window or needs a second pair of eyes. It also multiplies cost and the number of places things can fail. Start with one agent. Add more when you hit a wall.&lt;br&gt;
Key Components Explained Simply&lt;br&gt;
Five pieces come up in almost every project.&lt;br&gt;
Tool Discovery and Integration (APIs, MCP, Function Calling)&lt;br&gt;
Function calling allows an AI model to request specific functions, such as looking up an order or retrieving information from a database. The Model Context Protocol (MCP) provides a standardized way for AI applications to connect with external tools and data sources. Anthropic introduced MCP as an open-source project on November 25, 2024. In December 2025, Anthropic donated the protocol to the Linux Foundation's Agentic AI Foundation, supporting its development as an open industry standard. For a small project, ordinary function calling may be enough. MCP becomes useful when you need standardized connections across multiple tools and applications.&lt;br&gt;
Browser Automation and UI Interaction&lt;br&gt;
Some systems have no API. In that case an agent can drive a browser with a tool like Playwright and click through pages like a person would. It works, but it's slower and breaks when a site changes its layout. Use an API when you can.&lt;br&gt;
Authentication, Identity, and Secrets Management for Agents&lt;br&gt;
Give the agent its own identity. Don't hand it your login. Use narrow permissions (least privilege), keep keys in a secrets manager like HashiCorp Vault or your cloud's built-in one, and rotate them. Never paste an API key into a prompt.&lt;br&gt;
Memory Systems and Vector Databases&lt;br&gt;
Pinecone, Weaviate, Qdrant, Chroma, and pgvector all do this job. If you already run Postgres, pgvector is the easy first step. A dedicated vector database makes more sense once your data gets big. You may not need one at all for a first agent.&lt;br&gt;
Compute, Hosting, and Sandboxed Execution Environments&lt;br&gt;
If your agent writes and runs code, run it in a sandbox: a locked-down container that can't reach your real systems. Docker works for the basics, and services like E2B and Modal exist for this. Hosting itself can be a plain cloud server or serverless functions. GPUs only matter if you host your own model.&lt;br&gt;
Designing Infrastructure for Machine-Speed Operations&lt;br&gt;
Agents work faster than people and don't sleep. Your systems might not be ready for that.&lt;br&gt;
Why Human-Centric Systems Become Bottlenecks&lt;br&gt;
Approval emails, ticket queues, and manual logins were built for people. An agent can send hundreds of requests in the time a person opens one ticket, then sit there waiting for a human to click Approve.&lt;br&gt;
API-First and Agent-Native Architecture&lt;br&gt;
Agent-native means every action has a clean API, clear error messages, and predictable responses. If a task can only be done by clicking around a dashboard, agents struggle with it. Platform teams are starting to treat agents as a new kind of user, with their own needs.&lt;br&gt;
Scalability, Latency, and Concurrency Considerations&lt;br&gt;
Three things bite first: rate limits on the services you call, slow model responses, and many agents running at once. Use queues and retries, and make actions idempotent, so repeating a request doesn't repeat the side effect (like charging a card twice). Tools like Temporal handle long-running workflows.&lt;br&gt;
From "Self-Healing" Systems to Self-Architecting Ones&lt;br&gt;
Self-healing means a system can respond to known problems automatically, such as restarting a failed service. Self-architecting describes a more ambitious idea: agents design or modify infrastructure itself. These capabilities should not be treated as interchangeable, and autonomous infrastructure changes require strong testing, permissions, and rollback controls. For beginners, treat self-architecting systems as an emerging direction rather than a capability to assume is production-ready.&lt;br&gt;
Real-World Use Cases of AI Agent Infrastructure&lt;br&gt;
The real uses today are boring, in a good way.&lt;br&gt;
IT and Network Operations (Provisioning, Configuration, Capacity Planning)&lt;br&gt;
Agents provision servers, push config changes, check backups, and forecast capacity. Tools like Terraform and Ansible make the actual changes, and the agent decides when. Network teams worry most about blast radius here, since one bad config can take down a whole site.&lt;br&gt;
Illustrative scenario: An IT operations agent could review server alerts, summarize the likely cause of a problem, and prepare a configuration change for an engineer to approve. This is a hypothetical workflow; it should not be presented as a task the author has personally automated.&lt;br&gt;
Security Operations and Compliance&lt;br&gt;
Agents can help triage security alerts, gather relevant evidence, and draft incident reports. A human should review consequential actions, such as disabling an account or changing access permissions. Avoid claiming a specific time saving unless you have a reliable study or measured result for the exact workflow.&lt;br&gt;
Customer Support and Business Workflows&lt;br&gt;
A support agent looks up an order, checks the refund policy, issues a refund under a set limit, and escalates the rest. ServiceNow, Salesforce, and Zendesk all ship agent features now. Set the limit in code, not in the prompt.&lt;br&gt;
Software Development and DevOps&lt;br&gt;
Coding agents like GitHub Copilot, Cursor, and Claude Code write and test code. DevOps agents read logs when a deploy fails and suggest a fix or open a pull request for review.&lt;br&gt;
Build vs. Buy: Choosing Platforms, Frameworks, and Tools&lt;br&gt;
Short answer: use managed pieces first, and build only the parts that make your work different.&lt;br&gt;
Popular Frameworks and Orchestration Options (Open Source vs. Managed)&lt;br&gt;
Open source options like LangChain, LangGraph, LlamaIndex, CrewAI, and AutoGen give you control and cost engineering time. Managed platforms give you speed and cost more per use, with some lock-in.&lt;br&gt;
Cloud Provider Options (AWS, Azure, Google Cloud)&lt;br&gt;
AWS provides Amazon Bedrock, Microsoft offers Microsoft Foundry (formerly Microsoft Foundry (formerly Azure AI Foundry)), and Google Cloud provides Vertex AI. These platforms offer different combinations of model access, agent development, deployment, and enterprise infrastructure. If your organization already uses a particular cloud provider, starting with its existing AI platform can simplify identity management, billing, and security integration.&lt;br&gt;
Evaluation Checklist: Features, Cost, Lock-In, and Support&lt;br&gt;
Before you pick anything, ask:&lt;br&gt;
Does it log every step the agent takes?&lt;br&gt;
Can you set permissions per agent?&lt;br&gt;
What happens to your data? Is it used for training?&lt;br&gt;
What does it cost at ten times your expected usage?&lt;br&gt;
How hard is it to leave?&lt;br&gt;
Does support answer in hours or in weeks?&lt;br&gt;
A Sample Starter Stack for Beginners&lt;br&gt;
Here's a setup that keeps things small.&lt;br&gt;
Layer&lt;br&gt;
Starter choice&lt;br&gt;
Why&lt;br&gt;
Model&lt;br&gt;
One hosted LLM through an API&lt;br&gt;
No servers to run&lt;br&gt;
Tools&lt;br&gt;
Function calling to two or three APIs&lt;br&gt;
Simple to debug&lt;br&gt;
Memory&lt;br&gt;
Postgres with pgvector&lt;br&gt;
One database to manage&lt;br&gt;
Orchestration&lt;br&gt;
LangGraph or plain code&lt;br&gt;
Plain code is fine at first&lt;br&gt;
Observability&lt;br&gt;
Langfuse&lt;br&gt;
Hosting&lt;br&gt;
One small cloud container&lt;br&gt;
Cheap and easy to restart&lt;br&gt;
Before publishing, you can add an original screenshot of a starter stack you have personally configured. If you have not built one, keep the example table above and do not imply that it is your own deployed setup.&lt;br&gt;
Security, Safety, and Risk Management for AI Agents&lt;br&gt;
An agent with broad access and bad instructions is a real problem. Here's how it usually goes wrong.&lt;br&gt;
Key Risks: Prompt Injection, Over-Permissioned Agents, and Data Leakage&lt;br&gt;
Prompt injection occurs when malicious or misleading instructions in user input or external content influence an AI model to behave in unintended ways. For example, an agent reading an email or website might encounter hidden instructions designed to make it reveal sensitive information or perform an unauthorized action. OWASP ranks Prompt Injection as LLM01:2025, the first category in its 2025 Top 10 for Large Language Model Applications. Over-permissioned agents have access beyond what their tasks require, while data leakage occurs when private information is exposed to an unauthorized destination.&lt;br&gt;
Containment and Recovery: Planning for When Agents Fail&lt;br&gt;
Assume it will fail eventually. Limit what the agent can reach, set spending caps, keep a kill switch, and make actions reversible where you can. Take a snapshot before any change, and test the rollback before you need it.&lt;br&gt;
Human-in-the-Loop: Putting People at the Right Decision Points&lt;br&gt;
Don't approve every step. You'll get tired and start clicking yes without reading. Require approval for actions that are expensive, hard to undo, or visible to customers. Let low-risk reads run on their own.&lt;br&gt;
Compliance and Regulation Basics for U.S. Businesses&lt;br&gt;
The United States does not have one comprehensive federal statute specifically regulating every type of AI agent. However, this does not mean AI agents operate without legal requirements. Existing laws can apply depending on the industry, data involved, and actions an agent performs. For example, HIPAA applies to covered healthcare entities and their business associates, while Section 5 of the FTC Act prohibits unfair or deceptive practices in commerce. Colorado enacted Senate Bill 26-189 in May 2026, with provisions scheduled to take effect on January 1, 2027; the state also enacted a separate Chatbot Safety Act with the same scheduled effective date. SOC 2 is an independent attestation framework, not a law. Businesses should review applicable federal and state requirements with qualified legal counsel. The NIST AI Risk Management Framework can help organize AI risk-management practices.&lt;br&gt;
How to Adopt AI Agent Infrastructure Step by Step&lt;br&gt;
Don't start with full autonomy. Earn it.&lt;br&gt;
Phase 1: AI-Assisted (Humans Decide, AI Suggests)&lt;br&gt;
The AI drafts, summarizes, or recommends. A person does the actual work. Risk is low, and you learn where the agent is wrong before it can hurt anything.&lt;br&gt;
Phase 2: Supervised Execution (AI Acts, Humans Approve)&lt;br&gt;
Now the agent takes the action, but only after a person says yes. This is where you tune permissions and find the gaps in your guardrails.&lt;br&gt;
Phase 3: Autonomous Operations (AI Acts Within Guardrails)&lt;br&gt;
The agent acts alone, inside tight limits, on tasks with clear rules where a mistake is cheap. Keep logging on. Review a sample of its work every so often.&lt;br&gt;
How to Choose the Right Starting Problem (Risk, Clarity, Consequences)&lt;br&gt;
Ask three questions. Does the task need action, or just advice? Is it well defined? What happens if the agent gets it wrong? Good first picks are things like summarizing support tickets or drafting config changes for review. Bad first picks are anything that moves money or touches production with no review.&lt;br&gt;
Costs, Metrics, and Future Trends in AI Agent Infrastructure&lt;br&gt;
Most beginners underestimate the cost and skip the measuring. Don't.&lt;br&gt;
What AI Agent Infrastructure Really Costs (Compute, Tokens, Tooling, Staffing)&lt;br&gt;
Four buckets: model tokens, compute and hosting, tool subscriptions, and people. People are usually the biggest. AI agent infrastructure costs can increase as an agent performs more reasoning steps and makes additional model calls. Each call may involve input and output tokens, and some implementations pass previous conversation context into subsequent requests. This can increase input-token consumption, particularly in long-running workflows. However, the exact cost depends on the API, conversation-state design, prompt caching, and model selected. To control spending, monitor token usage per task, limit unnecessary reasoning loops, and check your provider's current pricing.&lt;br&gt;
How to Measure Success: Reliability, Cost Per Task, and ROI&lt;br&gt;
Track task success rate, cost per completed task, time saved, and how often humans override the agent. Compare against doing the work by hand. Start tracking before launch, or you'll have no baseline to compare with.&lt;br&gt;
Emerging Trends to Watch (Agent Interoperability Standards, Agent-to-Agent Communication, Operational Invisibility)&lt;br&gt;
AI agent interoperability is an important area of development. Two notable protocols are the Model Context Protocol (MCP) and Agent2Agent (A2A). MCP standardizes connections between AI applications and external tools or data sources. A2A focuses on communication and collaboration between different AI agents. Anthropic donated MCP to the Linux Foundation's Agentic AI Foundation in December 2025, while the Linux Foundation launched the A2A project in June 2025. Both initiatives aim to improve interoperability, but their long-term adoption and implementation will continue to evolve. Operational invisibility describes the goal of infrastructure running reliably in the background; it is an aspiration, not a formal technical standard.&lt;br&gt;
Frequently Asked Questions About AI Agent Infrastructure&lt;br&gt;
What is AI agent infrastructure in simple terms?&lt;br&gt;
It's the set of systems that lets an AI model do tasks instead of just chatting: tools to act, memory to remember, orchestration to coordinate, and controls to keep it safe.&lt;br&gt;
What are the main components of an AI agent infrastructure stack?&lt;br&gt;
A model, tools, data and memory, orchestration, and observability with governance. Add hosting underneath and security across all of it.&lt;br&gt;
How is AI agent infrastructure different from traditional IT or MLOps infrastructure?&lt;br&gt;
Traditional apps follow fixed code paths. MLOps focuses on training and serving models. Agent infrastructure has to handle software that makes its own decisions at run time, so permissions, logging, and rollback matter a lot more.&lt;br&gt;
Do I need to build my own infrastructure, or can I use a managed platform?&lt;br&gt;
Most beginners should use a managed platform or a framework on top of a hosted model. Build custom pieces later, once you know where the managed options fall short.&lt;br&gt;
Is AI agent infrastructure safe for business use?&lt;br&gt;
It can be, with limits. Give agents narrow permissions, require approval for risky actions, log everything, and plan for failure. Safe depends on how you set it up, not on the tool.&lt;br&gt;
What is the difference between the Big Four accounting firms' AI platforms?&lt;br&gt;
The Big Four accounting firms have introduced separate enterprise AI initiatives: Deloitte announced Zora AI, PwC launched agent OS, EY introduced the EY.ai Agentic Platform, and KPMG launched KPMG Workbench. These products have different capabilities and deployment status, so they should not be treated as identical.&lt;br&gt;
Is there an official list of the Big Four AI companies?&lt;br&gt;
No. The phrase does not have a universally accepted definition. Some discussions refer to companies, while others refer to products. Compare companies with companies and products with products rather than treating them as one official ranking.&lt;br&gt;
What are the five components of an AI agent?&lt;br&gt;
One useful teaching model includes perception, reasoning, memory, planning, and action. This is a conceptual framework, not a universal technical standard. Some architectures combine these functions or include additional components.&lt;br&gt;
Is there a 30% rule of AI?&lt;br&gt;
There is no established rule that divides work into 70% AI and 30% human effort. A May 2024 McKinsey Global Institute report estimated that, under its midpoint adoption scenario, up to 30% of current working hours in the United States and Europe could be automated by 2030. This is a scenario-based forecast, not a guaranteed outcome or a recommended work split.&lt;br&gt;
Which five jobs will survive AI?&lt;br&gt;
No reliable source can guarantee that five specific occupations will survive AI unchanged. U.S. Bureau of Labor Statistics projections show expected employment growth in several occupations, including electricians, plumbers, registered nurses, and mental health counselors, but these are labor-market projections—not guarantees of protection from AI.&lt;br&gt;
Your Next Step&lt;br&gt;
Choose one small, low-risk task, such as summarizing support tickets. Begin with an AI-assisted workflow in which the agent makes suggestions and a person decides what to do. Record errors and review the results before granting the agent permission to take actions.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>webdev</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Latest News in Cloud AI: Transforming Land Surveying With AI and Drone Technology</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Fri, 30 Oct 2026 13:38:37 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/latest-news-in-cloud-ai-transforming-land-surveying-with-ai-and-drone-technology-4i8g</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/latest-news-in-cloud-ai-transforming-land-surveying-with-ai-and-drone-technology-4i8g</guid>
      <description>&lt;p&gt;Land surveying has always been a race between fieldwork and paperwork. A crew can walk a site for days, and then technicians can spend more days turning raw measurements into maps, terrain models, and drawings. Drones, LiDAR sensors, and cloud-based software are now shrinking both halves of that equation, and AI drone land surveying is the term many in the industry use for the combined workflow.&lt;br&gt;
The topic got fresh attention in October 2026. On October 22, ZenaTech announced a proprietary AI software suite designed to process LiDAR data from its drone-based land surveying operations. A week later, on October 29, the company said it anticipates faster survey delivery and more capacity as it adds Australian surveying firms to its Drone as a Service (DaaS) network.&lt;br&gt;
This matters to surveyors, developers, construction companies, and technology watchers for the same reason: if routine point cloud processing can be automated reliably, the bottleneck in many survey projects moves. This article explains what was announced, what is still only planned, how the underlying technology works, and where the real limits are.&lt;br&gt;
Latest Cloud AI News in Land Surveying&lt;br&gt;
What ZenaTech announced&lt;br&gt;
On October 22, 2026, ZenaTech (Nasdaq: ZENA) unveiled an AI software suite, referred to in later materials as ZenaAI, intended to work with LiDAR data captured by its ZenaDrone land survey drones. The company described four planned capabilities:&lt;br&gt;
Automated point cloud classification using deep learning to separate ground, vegetation, buildings, and utility lines, supporting digital terrain models.&lt;br&gt;
Automated feature extraction and linework, using computer vision to detect features such as curb lines, pavement edges, and retaining walls and export them to CAD and BIM formats.&lt;br&gt;
Faster turnaround, with the company saying the software is designed to cut post-processing work by as much as 80%.&lt;br&gt;
Noise filtering and asset tagging, aimed at removing artifacts and logging items such as manholes, hydrants, and utility poles.&lt;br&gt;
The company's stated goal is to move survey-grade data delivery from days to as little as hours or minutes.&lt;br&gt;
What is confirmed and what is not&lt;br&gt;
The status matters more than the headline. ZenaTech says the combined platform is currently in the development and testing stage. In its October 29 release, the company said the software is expected to begin formal testing across its DaaS network in 2027. In other words, this is not a commercially available product with published customer results.&lt;br&gt;
The October 29 release also contained a company-internal comparison for a representative 100-acre topographic survey. It estimated that conventional ground methods cover about 3 acres per day, or roughly 267 hours of fieldwork, versus about 65 hours with a drone. The company framed that as potential fieldwork savings equivalent to more than 25 eight-hour workdays. These are internal estimates, not independently verified results. ZenaTech also said it is preparing documented case studies and will report verified results once they are complete.&lt;br&gt;
The same release noted that survey teams review classifications and verify accuracy before any deliverable reaches a client, and that actual results vary with site conditions, vegetation, accuracy requirements, and deliverables.&lt;br&gt;
The business context&lt;br&gt;
The October 29 announcement was tied to acquisitions. ZenaTech said it closed its 30th and 31st DaaS acquisitions, Byrne Consultants in Darwin and Hopkins Consultants in Port Macquarie, New South Wales, bringing its Australian footprint to seven locations. The company's strategy is to combine local surveying providers into a network that could share a common AI processing workflow. Whether that works at scale is something only real deployments will show.&lt;br&gt;
One caution for readers: some market commentary around this news is paid promotional content. Third-party market forecasts cited in such material, such as estimates for surveying services, geospatial analytics, and AI in construction, describe separate, overlapping markets and should not be read as the size of an "AI land surveying" market.&lt;br&gt;
How AI and Drone Technology Work Together&lt;br&gt;
A modern drone survey is a chain of steps, and AI mostly sits in the middle and at the end.&lt;br&gt;
Data acquisition. A drone flies a planned route and captures data with one or more sensors. Photogrammetry uses overlapping photographs to reconstruct surfaces in 3D. LiDAR fires laser pulses and measures their return times, producing a dense set of 3D points. LiDAR can capture ground beneath some vegetation and works in lighting conditions that challenge cameras.&lt;br&gt;
Positioning and control. Data is only as trustworthy as its position. Drones typically use GNSS (satellite positioning) with correction methods, and surveyors still place ground control points and check points measured with ground equipment. ZenaTech's own description says surveyors continue to use ground-based equipment to set control points and verify accuracy, with the drone taking over routine terrain measurement.&lt;br&gt;
Processing. Raw data is merged, aligned, cleaned, and turned into a point cloud or image mosaic. This is where AI-based classification and feature extraction are intended to save time.&lt;br&gt;
Engineering outputs. Classified data becomes terrain models, contour lines, planimetric drawings, volume calculations, and files for CAD or BIM software.&lt;br&gt;
Human review and quality assurance. A qualified surveyor checks the classification, compares results against control points, and signs off. AI can propose; the professional remains accountable.&lt;br&gt;
What Is AI-Powered LiDAR Point Cloud Processing?&lt;br&gt;
Point clouds in plain language&lt;br&gt;
A point cloud is a huge collection of dots in 3D space. Each dot has a position and often extra data such as intensity or color. A drone survey of one site can produce millions to billions of points. On their own, they are just dots. The surveyor needs to know which dots are bare ground, which are tree canopy, which are a building roof, and which are a power line.&lt;br&gt;
What AI is asked to do&lt;br&gt;
Ground and vegetation classification: Deep learning models learn patterns from labeled examples, then label new points. Separating true ground from low brush and dense canopy is one of the hardest and most valuable steps, because the ground surface becomes the digital terrain model.&lt;br&gt;
Building and infrastructure identification: Models identify roofs, walls, poles, and lines so that structures can be excluded from terrain models or extracted as features.&lt;br&gt;
Noise filtering: Stray returns from birds, dust, reflective surfaces, or overlapping flight lines can be flagged and removed.&lt;br&gt;
Terrain modeling: Once ground points are identified, software interpolates a continuous surface.&lt;br&gt;
Feature extraction: Computer vision can trace edges such as curbs, pavement edges, and retaining walls and convert them into vector linework.&lt;br&gt;
CAD and BIM preparation: The vectorized features and surfaces are exported in formats engineers can use.&lt;br&gt;
A practical example&lt;br&gt;
Imagine a hypothetical drone survey of a residential development site with cleared land, a partly wooded boundary, a gravel access road, and a few existing structures. This is an illustration, not a real customer case.&lt;br&gt;
The team sets ground control points and flies a LiDAR and camera mission.&lt;br&gt;
The flight data is merged into one point cloud.&lt;br&gt;
An AI classifier labels points as ground, vegetation, building, road surface, and so on.&lt;br&gt;
A surveyor reviews the results, correcting areas where scrub was labeled as ground or where a retaining wall was missed.&lt;br&gt;
The corrected ground class produces a terrain model. Contours and volume estimates follow.&lt;br&gt;
Feature extraction proposes road edges and building outlines as CAD linework, which the surveyor checks before delivery.&lt;br&gt;
The AI's value is in steps 3 and 6, where it creates a first draft. Step 4 is where professional judgment still decides quality.&lt;br&gt;
How Cloud AI Can Accelerate Land Surveying&lt;br&gt;
It is worth being precise here. ZenaTech's announcements describe AI software and drone integration, but they do not detail a specific cloud architecture. What follows is general industry context about what cloud infrastructure can do, not a description of ZenaAI's design.&lt;br&gt;
Large datasets: Point clouds and imagery can run to many gigabytes per project. Cloud storage lets teams keep them centrally instead of moving drives around.&lt;br&gt;
Scalable computing: Processing and AI inference can use many servers or GPUs when needed and scale down afterward, which suits uneven project workloads.&lt;br&gt;
Remote collaboration: A field team, an office technician, and an engineer in another city can view the same project data.&lt;br&gt;
Automated pipelines: Uploading a dataset can trigger a sequence of steps: alignment, classification, surface generation, and export.&lt;br&gt;
Workflow integration: Outputs can feed into engineering, GIS, and construction software.&lt;br&gt;
Cloud and AI are not the same thing. AI models can run in the cloud, on a powerful office workstation, or on specialized hardware near the sensor. This is often called edge processing, and it reduces dependence on connectivity, which matters at remote sites. A well-designed workflow may mix them: quick quality checks on site, heavy processing in the cloud or office.&lt;br&gt;
Key Benefits of AI Drone Land Surveying&lt;br&gt;
When it works well, AI drone land surveying can offer several potential benefits:&lt;br&gt;
Less manual processing: Automating repetitive classification and tracing frees technicians for review and complex work.&lt;br&gt;
Faster turnaround: Earlier deliverables can mean earlier permitting, design, or construction starts.&lt;br&gt;
Operational efficiency: The same crew may handle more projects if office work stops being the bottleneck.&lt;br&gt;
Access to large or difficult sites: Drones can cover steep, large, or hazardous areas without surveyors walking every meter.&lt;br&gt;
More frequent monitoring: Repeat flights make it practical to track earthworks or progress regularly.&lt;br&gt;
Better collaboration: Shared digital outputs give surveyors and engineers the same up-to-date view.&lt;br&gt;
These are potential benefits, not guarantees. Real accuracy, time savings, and cost reductions depend on the equipment, site conditions, vegetation, survey specifications, software quality, and professional verification. Any claim of a single universal percentage should be treated as an estimate until independently tested.&lt;br&gt;
Real-World Applications Across Industries&lt;br&gt;
The examples below are typical use cases, not named customer case studies.&lt;br&gt;
Construction and land development: Topographic surveys, earthwork volumes, and progress monitoring against design models.&lt;br&gt;
Roads and infrastructure planning: Corridor mapping, drainage analysis, and extraction of curbs, pavement edges, and utilities.&lt;br&gt;
Mining and earthworks: Stockpile volumes and pit or slope change tracking.&lt;br&gt;
Agriculture and terrain analysis: Field elevation models, drainage patterns, and crop-related analysis using additional sensors.&lt;br&gt;
Utilities and asset inspections: Surveying around power lines, poles, and pipelines, and logging assets.&lt;br&gt;
Municipal planning and environmental monitoring: Land-use mapping, erosion monitoring, and habitat or shoreline change.&lt;br&gt;
Academic interest is growing too. A 2025 systematic review in the journal Drone Systems and Applications examined 33 studies on AI- and IoT-enabled drones in construction, a sign that this is an active research field and not only a vendor topic. Related work in water surveying shows the same data-fusion logic: a 2022 Hydro International feature described combining data from an uncrewed surface vessel and a drone to build digital bathymetric models of shallow water.&lt;br&gt;
AI Surveying Software and Traditional Methods Compared&lt;br&gt;
Factor&lt;br&gt;
Traditional ground survey&lt;br&gt;
Drone survey with manual processing&lt;br&gt;
Drone survey with AI-assisted processing&lt;br&gt;
Data collection&lt;br&gt;
Point-by-point measurement on foot with total stations or GNSS&lt;br&gt;
Aerial capture with LiDAR or photogrammetry&lt;br&gt;
Same aerial capture&lt;br&gt;
Processing&lt;br&gt;
Mostly manual drafting and calculation&lt;br&gt;
Software-assisted but technician-heavy classification and linework&lt;br&gt;
Automated first-pass classification and feature extraction, with review&lt;br&gt;
Turnaround&lt;br&gt;
Slower for large sites&lt;br&gt;
Faster fieldwork, office work can still take days&lt;br&gt;
Intended to be faster; results still unverified for emerging products&lt;br&gt;
Scalability&lt;br&gt;
Limited by crew time&lt;br&gt;
Better coverage per day&lt;br&gt;
Potentially better, if automation proves reliable&lt;br&gt;
Quality assurance&lt;br&gt;
Direct measurement and checks&lt;br&gt;
Control points, checks, technician review&lt;br&gt;
Control points plus review of AI output; model errors need catching&lt;br&gt;
Human involvement&lt;br&gt;
High throughout&lt;br&gt;
High in processing&lt;br&gt;
Concentrated in planning, control, review, and sign-off&lt;/p&gt;

&lt;p&gt;Traditional methods remain the reference for many high-precision tasks, such as boundary and legal work, where direct measurement and professional judgment are central. AI-assisted workflows do not automatically outperform them; they shift where the effort goes.&lt;br&gt;
Challenges and Limitations of AI-Powered Surveying&lt;br&gt;
Data quality and sensors: AI cannot fix poor data. Sparse points, misalignment, or sensor limits flow straight into results. A 2022 study on combining drone and surface-vessel data found photogrammetry could only capture data to about 1.3 meters of water depth because of poor water clarity, and its method required an underwater control network and suited small areas. Every sensor has conditions where it fails.&lt;br&gt;
Vegetation and difficult terrain: Dense canopy, low scrub, steep slopes, and reflective or wet surfaces make ground classification harder.&lt;br&gt;
Survey-grade accuracy: Absolute accuracy depends heavily on GNSS quality and ground control, not just AI. Claims of very fine precision, including those in vendor material, need validation against control points on real projects.&lt;br&gt;
Ground control and GNSS limits: Poor satellite visibility or correction signals can degrade positioning.&lt;br&gt;
Privacy and security: Aerial data can capture people, property, and critical infrastructure. Storage, access control, and contract terms about data use need attention.&lt;br&gt;
Cloud costs: Storing and processing large datasets in the cloud has recurring costs that should be modeled.&lt;br&gt;
Regulations: Drone rules on flight altitude, line of sight, airspace, and operator licensing vary by country and can limit operations.&lt;br&gt;
Professional validation: Qualified surveyors remain responsible for deliverables. AI output is a draft until someone accountable checks it.&lt;br&gt;
What This Development Means for Surveying Businesses&lt;br&gt;
Small firms may see an opportunity to handle more projects without proportional hiring, but they also face a decision about training, software cost, and data handling. Waiting for independent results before committing is reasonable.&lt;br&gt;
Enterprise providers can benefit from standardized workflows across offices, which is the strategy ZenaTech describes for its network. Consistency is valuable, but only if the standard process is accurate.&lt;br&gt;
Construction businesses stand to gain from faster, more frequent site data if delivery times genuinely shorten. They should still ask providers how deliverables are verified.&lt;br&gt;
Drone-service companies may find processing speed becomes a differentiator, and also that clients increasingly ask about accuracy statements and quality control.&lt;br&gt;
Automation can take over repetitive steps, but expertise becomes more important at the edges: designing control, judging ambiguous terrain, reviewing AI output, and taking professional responsibility.&lt;br&gt;
What to Watch Next in Cloud AI and Drone Mapping&lt;br&gt;
Testing progress: ZenaTech has said formal testing is expected in 2027. Watch for updates on timing and scope.&lt;br&gt;
Verified results: The company says it is preparing documented case studies. Independent or third-party validation would carry more weight than internal estimates.&lt;br&gt;
Commercial availability: Whether and how the software becomes a product, and under what terms, is not yet established.&lt;br&gt;
Accuracy reporting: Published accuracy figures against control points, across different terrain and vegetation conditions.&lt;br&gt;
Integration: How well outputs fit with established surveying, CAD, and BIM tools.&lt;br&gt;
Real deployments: Evidence from live projects across the acquired firms and other providers.&lt;br&gt;
None of these outcomes is guaranteed, and this article does not predict launch dates or business results.&lt;br&gt;
Conclusion&lt;br&gt;
AI, drone-based data collection, LiDAR, and cloud processing are changing land surveying by targeting its slowest step: turning raw measurements into usable maps and drawings. The October 2026 ZenaTech announcements show where the industry is heading, but they also show how early parts of this shift remain. The software is in development and testing, and the headline time savings are company estimates.&lt;br&gt;
For anyone evaluating AI drone land surveying, the practical takeaway is balanced. Automation can improve efficiency, but reliable results still depend on suitable equipment, accurate data, proper ground control, professional oversight, and verification. The technology is worth watching closely, and worth testing carefully.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;/li&gt;
&lt;/ol&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
    <item>
      <title>CRWV vs. MSFT: Which AI Cloud Stock Offers Better Upside Potential?</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Thu, 29 Oct 2026 16:37:59 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/crwv-vs-msft-which-ai-cloud-stock-offers-better-upside-potential-40jg</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/crwv-vs-msft-which-ai-cloud-stock-offers-better-upside-potential-40jg</guid>
      <description>&lt;p&gt;Introduction&lt;br&gt;
AI has turned cloud infrastructure into one of the most closely watched investment themes in the market. Training and running large models requires enormous amounts of GPU capacity, power and data center space, and the companies that supply it are spending at a scale few industries have ever seen.&lt;/p&gt;

&lt;p&gt;Two stocks sit at opposite ends of that trade. CoreWeave (NASDAQ: CRWV) is a specialized, debt-funded AI cloud built around GPUs. Microsoft (NASDAQ: MSFT) is a diversified giant that combines Azure, enterprise software, and AI products such as Microsoft 365 Copilot. One of them offers far more percentage upside if everything goes right; the other offers a far sturdier floor if something goes wrong.&lt;/p&gt;

&lt;p&gt;This CRWV vs MSFT comparison looks at the latest reported numbers, management guidance, valuation and risk, to answer a single question: which AI cloud stock has the stronger risk-adjusted upside potential? Throughout the article we label what is a reported fact, what is management guidance, what is an analyst view, and what is our own interpretation.&lt;/p&gt;

&lt;p&gt;Why now? Microsoft reported fiscal Q1 2027 results on October 28, 2026, and CoreWeave’s stock has been through a sharp October sell-off driven by debt concerns. The gap between the two stories has rarely been wider.&lt;/p&gt;

&lt;p&gt;CoreWeave vs. Microsoft-Business Model Comparison&lt;br&gt;
CoreWeave rents out GPU-based computing capacity, mainly to AI labs, hyperscalers and a growing number of enterprises, under long-term contracts. Its pitch is speed and specialization: purpose-built infrastructure for training, inference and managed AI services. The model is capital-intensive. CoreWeave buys GPUs and builds or leases data centers, often financed with debt backed by customer contracts, and earns revenue as capacity comes online.&lt;/p&gt;

&lt;p&gt;Microsoft sells compute as one part of a much larger ecosystem: Azure, Microsoft 365, Dynamics, LinkedIn, GitHub, security tools, gaming and more. AI is layered across all of it, from Azure AI Foundry to Copilot. Its infrastructure spending is funded largely from operating cash flow, and a recurring software base cushions the business if AI demand wobbles.&lt;/p&gt;

&lt;p&gt;There is also a direct link between the two. According to an independent analysis of CoreWeave’s filings, Microsoft accounted for roughly two-thirds of CoreWeave’s 2025 revenue. In other words, CoreWeave is partly a play on hyperscalers outsourcing capacity, and Microsoft is one of its largest customers.&lt;/p&gt;

&lt;p&gt;CoreWeave (CRWV) Stock Analysis&lt;br&gt;
Latest results (Q2 2026, quarter ended June 30, 2026; reported August 11, 2026).&lt;/p&gt;

&lt;p&gt;Revenue of about $2.58 billion, up 112% year over year and roughly 24% sequentially.&lt;br&gt;
Adjusted operating income of $128 million (about a 5% margin), up from $21 million in Q1. Adjusted EBITDA was about $1.5 billion (59% margin).&lt;br&gt;
Net loss of $626 million, with net interest expense of $640 million. In our reading, the interest bill alone explains almost the entire loss.&lt;br&gt;
Revenue backlog of about $104 billion at June 30, up roughly 246% year over year. Management said this excludes more than $25 billion of new commitments signed in early Q3.&lt;br&gt;
Capacity and expansion. Active power rose by about 500 MW in the quarter to roughly 1.5 GW. Management is targeting more than 8 GW of active power by 2030 and is expanding into Europe, the Middle East and Asia-Pacific. Managed inference ARR has grown from about $1 million at launch to more than $100 million, with management targeting at least $250 million by year-end. Note: sources differ on contracted power (about 3.7 GW in one report, 4.2 GW in another), so confirm the exact figure in the Q2 shareholder materials before quoting it.&lt;/p&gt;

&lt;p&gt;Capex and financing. Q2 capital expenditures were about $9.4 billion, and full-year 2026 capex guidance was raised to $35–$39 billion. CoreWeave raised more than $18 billion of capital during the quarter through debt, equity and convertibles, including a $1 billion strategic investment from Jane Street, and says it lowered its average cost of debt. Still, Q3 interest expense is guided to $860–$940 million.&lt;/p&gt;

&lt;p&gt;Management guidance (not a forecast by us). For 2026: revenue of $12.4–$13.2 billion, adjusted operating income of $960 million to $1.15 billion, and exit annualized run-rate revenue of $18.5–$19.5 billion. For Q3: revenue of $3.45–$3.60 billion and adjusted operating income of $200–$260 million. Management also pointed to sold-out capacity and price increases of roughly 25% in July, per press coverage.&lt;/p&gt;

&lt;p&gt;Catalysts. Conversion of the backlog into live capacity; newer GPU generations such as Vera Rubin with better contract margins; growth in inference workloads; NVIDIA’s continued support (including its expanded equity investment earlier this year); and customer diversification.&lt;/p&gt;

&lt;p&gt;Major risks. Debt and interest costs; customer concentration (three customers made up 72% of Q2 revenue, and two accounted for 32% of receivables each); heavy dilution risk; execution delays in power and data center delivery; and extreme share-price volatility. In mid-October, concerns about a debt load that Reuters-cited coverage put near $50 billion helped trigger a sell-off, and yields on CoreWeave’s 2030 bonds were reported near 16% at the peak of the stress. UBS cut its price target to $105 from $120 on October 23, and HSBC reiterated a bearish stance on debt risk.&lt;/p&gt;

&lt;p&gt;Microsoft (MSFT) Stock Analysis&lt;br&gt;
Latest results (fiscal Q1 2027, quarter ended September 30, 2026; reported October 28, 2026).&lt;/p&gt;

&lt;p&gt;Revenue of $92.3 billion, up 19%. Operating income of $45.9 billion, up 21% (an operating margin near 50%).&lt;br&gt;
Net income of $36.6 billion, up 32% on a GAAP basis ($36.4 billion, up 18%, non-GAAP).&lt;br&gt;
Azure revenue grew 48% to about $33.2 billion, the first time Microsoft disclosed Azure in dollar terms. Microsoft Cloud revenue rose 30% to $63.9 billion.&lt;br&gt;
Commercial remaining performance obligation rose 73% to $677 billion.&lt;br&gt;
AI monetization. Microsoft 365 Copilot passed 30 million paid seats as of its July report, and the company has rolled out a unified Copilot experience plus agentic development tools. Azure is the larger engine: management says demand continues to outrun supply.&lt;/p&gt;

&lt;p&gt;Cash generation and capital spending. Free cash flow was $18.6 billion, down 27% year over year. Capex including finance leases was $45.2 billion, with cash spending on property and equipment of $39.4 billion. Management guided fiscal Q2 revenue to $96–$97.1 billion with Azure growth of 49–50% and capex above $50 billion. Microsoft also said it expects to remain free-cash-flow positive through fiscal 2027.&lt;/p&gt;

&lt;p&gt;An accounting detail worth knowing. In July, Microsoft extended the useful life it uses for long-term data center leases from 15 to 25 years, which lowers reported capex. The company said underlying spending plans are unchanged. It also disclosed $329.1 billion of data center leases that have not yet commenced.&lt;/p&gt;

&lt;p&gt;Catalysts. Continued Azure acceleration; the large contracted backlog; Copilot and agent adoption; custom silicon and efficiency gains; and its stake in OpenAI.&lt;/p&gt;

&lt;p&gt;Major risks. Enormous capex with falling free cash flow; large lease commitments; weakness in Windows OEM and Devices (Windows OEM revenue fell 22%, according to one report); intense competition from Google Cloud and Amazon; and the possibility that AI revenue does not grow fast enough to justify the spending.&lt;/p&gt;

&lt;p&gt;CRWV vs. MSFT-Financial Performance&lt;br&gt;
These figures come from different reporting periods and different business models. Treat the table as a snapshot, not an apples-to-apples ranking.&lt;/p&gt;

&lt;p&gt;Metric&lt;/p&gt;

&lt;p&gt;CoreWeave (Q2 2026, ended Jun 30)&lt;/p&gt;

&lt;p&gt;Microsoft (FQ1 2027, ended Sep 30)&lt;/p&gt;

&lt;p&gt;Revenue&lt;/p&gt;

&lt;p&gt;~$2.58 billion&lt;/p&gt;

&lt;p&gt;$92.3 billion&lt;/p&gt;

&lt;p&gt;Year-over-year growth&lt;/p&gt;

&lt;p&gt;+112%&lt;/p&gt;

&lt;p&gt;+19%&lt;/p&gt;

&lt;p&gt;Operating income&lt;/p&gt;

&lt;p&gt;$128 million adjusted (~5% margin)&lt;/p&gt;

&lt;p&gt;$45.9 billion (~50% margin, +21%)&lt;/p&gt;

&lt;p&gt;Net income / loss&lt;/p&gt;

&lt;p&gt;Net loss of $626 million&lt;/p&gt;

&lt;p&gt;Net income of $36.6 billion (+32% GAAP)&lt;/p&gt;

&lt;p&gt;Interest expense&lt;/p&gt;

&lt;p&gt;$640 million net&lt;/p&gt;

&lt;p&gt;Not a major factor&lt;/p&gt;

&lt;p&gt;Capital expenditures&lt;/p&gt;

&lt;p&gt;~$9.4 billion&lt;/p&gt;

&lt;p&gt;$45.2 billion incl. finance leases&lt;/p&gt;

&lt;p&gt;Free cash flow&lt;/p&gt;

&lt;p&gt;Negative per press coverage; confirm in the 10-Q&lt;/p&gt;

&lt;p&gt;$18.6 billion (down 27%)&lt;/p&gt;

&lt;p&gt;Backlog&lt;/p&gt;

&lt;p&gt;~$104 billion (+246%), plus $25 billion+ added in early Q3&lt;/p&gt;

&lt;p&gt;$677 billion commercial RPO (+73%)&lt;/p&gt;

&lt;p&gt;Leverage&lt;/p&gt;

&lt;p&gt;Total liabilities of ~$72 billion and debt-to-equity near 8.9 (Q2); net debt of roughly $30 billion at June 30 per one data provider&lt;/p&gt;

&lt;p&gt;Funded mainly by operating cash flow; large undisclosed-timing lease commitments&lt;/p&gt;

&lt;p&gt;Next-period guidance&lt;/p&gt;

&lt;p&gt;Q3 revenue $3.45–$3.60 billion&lt;/p&gt;

&lt;p&gt;FQ2 revenue $96–$97.1 billion, Azure +49–50%&lt;/p&gt;

&lt;p&gt;Where the comparison breaks down. CoreWeave’s backlog counts only AI compute contracts and depends on its ability to deliver capacity. Microsoft’s RPO spans its whole commercial business. CoreWeave’s profit metrics are mostly adjusted, while Microsoft’s are GAAP and heavily profitable. Debt figures also vary by definition (gross debt, net debt, leases), so check the latest 10-Q before quoting any single number.&lt;/p&gt;

&lt;p&gt;Valuation-Which Stock Is More Attractively Priced?&lt;br&gt;
Measure&lt;/p&gt;

&lt;p&gt;CRWV&lt;/p&gt;

&lt;p&gt;MSFT&lt;/p&gt;

&lt;p&gt;Recent price&lt;/p&gt;

&lt;p&gt;~$63.93 (Oct 28 close); 52-week range $51.24–$141.79&lt;/p&gt;

&lt;p&gt;~$524.51 (Oct 23 close); rose 2–4% after hours on Oct 28&lt;/p&gt;

&lt;p&gt;Market cap&lt;/p&gt;

&lt;p&gt;~$33–35 billion&lt;/p&gt;

&lt;p&gt;~$3.9 trillion&lt;/p&gt;

&lt;p&gt;Price-to-book (Zacks)&lt;/p&gt;

&lt;p&gt;5.84x&lt;/p&gt;

&lt;p&gt;8.91x&lt;/p&gt;

&lt;p&gt;Trailing P/E&lt;/p&gt;

&lt;p&gt;Not meaningful (loss-making)&lt;/p&gt;

&lt;p&gt;~29x&lt;/p&gt;

&lt;p&gt;Price-to-sales (our estimate)&lt;/p&gt;

&lt;p&gt;~2.7x on 2026 guidance midpoint ($12.8 billion)&lt;/p&gt;

&lt;p&gt;11x on trailing twelve-month revenue ($346 billion)&lt;/p&gt;

&lt;p&gt;Zacks Rank&lt;/p&gt;

&lt;h1&gt;
  
  
  3 (Hold)
&lt;/h1&gt;

&lt;h1&gt;
  
  
  3 (Hold)
&lt;/h1&gt;

&lt;p&gt;Price-to-sales figures are our own rough calculations using the market caps above and are not directly comparable, because one uses forward guidance and the other trailing revenue. Prices move daily, so refresh them on the day of publication.&lt;/p&gt;

&lt;p&gt;On the surface, CoreWeave looks cheaper: lower price-to-book, lower price-to-sales and a share price far below its 52-week high. But a lower multiple does not automatically mean undervalued. CoreWeave’s enterprise value is much larger than its market cap once roughly $30 billion or more of net debt is included (about 5x 2026 guided revenue, before lease liabilities, by our rough math). Its earnings are negative, its interest bill is growing faster than its operating income, and further equity or convertible issuance could dilute shareholders. Microsoft pays a premium multiple, but it earns it through roughly 50% operating margins, tens of billions in quarterly profit, and diversified revenue.&lt;/p&gt;

&lt;p&gt;Analyst estimate trends tell a similar story. Per Zacks, the 2026 earnings estimate for CoreWeave has been revised down over the past 60 days, while Microsoft’s has seen minimal upward revision.&lt;/p&gt;

&lt;p&gt;Growth Catalysts Through 2027 and Beyond&lt;br&gt;
Management guidance. CoreWeave expects active power to climb toward 8 GW by 2030 and exit 2026 at an annualized revenue run rate of $18.5–$19.5 billion. Microsoft expects another year of double-digit revenue and operating income growth in fiscal 2027, with Azure growth accelerating into fiscal Q2.&lt;/p&gt;

&lt;p&gt;Industry context. One market-research estimate (Fortune Business Insights) puts the global cloud AI market at $133.4 billion in 2026, growing to $780.6 billion by 2034 (a 23.8% CAGR). Third-party market sizing is a rough guide, not a guarantee.&lt;/p&gt;

&lt;p&gt;Our interpretation of what matters most:&lt;/p&gt;

&lt;p&gt;Capacity delivery. Both companies say demand exceeds supply. The winner is whoever turns backlog into live, paying capacity fastest, which depends on power, data center construction and GPU supply.&lt;br&gt;
GPU pricing and utilization. CoreWeave benefits when capacity is sold out and prices rise; it is exposed if pricing softens or newer chips make older clusters less valuable.&lt;br&gt;
Enterprise adoption. Microsoft is better placed to monetize AI through software and Copilot seats, while CoreWeave depends more on a handful of AI labs and hyperscalers, though it is broadening into enterprises and inference.&lt;br&gt;
Financing costs. CoreWeave’s upside hinges on lowering its cost of capital. Rising rates or stressed bond markets can quickly damage the thesis.&lt;br&gt;
Competition. Google Cloud reported very strong growth this quarter, other neoclouds such as Nebius are scaling, and some of CoreWeave’s own customers are building capacity.&lt;br&gt;
AI spending sustainability. If the market begins to doubt returns on AI capex, leveraged names are likely to be hit harder than cash-rich ones.&lt;br&gt;
CRWV vs. MSFT-Key Risks&lt;/p&gt;

&lt;p&gt;Risk&lt;/p&gt;

&lt;p&gt;CoreWeave (CRWV)&lt;/p&gt;

&lt;p&gt;Microsoft (MSFT)&lt;/p&gt;

&lt;p&gt;Debt and financing&lt;/p&gt;

&lt;p&gt;Very high. Interest expense of $640 million in Q2 and guided to $860–$940 million in Q3; bond yields spiked in October&lt;/p&gt;

&lt;p&gt;Low relative to cash generation; large lease commitments to monitor&lt;/p&gt;

&lt;p&gt;Customer concentration&lt;/p&gt;

&lt;p&gt;Very high. Three customers were 72% of Q2 revenue&lt;/p&gt;

&lt;p&gt;Low; diversified across millions of customers&lt;/p&gt;

&lt;p&gt;Capital intensity&lt;/p&gt;

&lt;p&gt;Extreme. 2026 capex of $35–$39 billion versus revenue of $12.4–$13.2 billion&lt;/p&gt;

&lt;p&gt;Very high in dollars (above $50 billion in FQ2), but funded by profits&lt;/p&gt;

&lt;p&gt;Competition&lt;/p&gt;

&lt;p&gt;Hyperscalers, other neoclouds and its own customers&lt;/p&gt;

&lt;p&gt;Google Cloud, Amazon and AI-native rivals&lt;/p&gt;

&lt;p&gt;Execution&lt;/p&gt;

&lt;p&gt;Power, construction and GPU delivery delays can push revenue out&lt;/p&gt;

&lt;p&gt;Capacity constraints may cause missed Azure revenue&lt;/p&gt;

&lt;p&gt;Valuation&lt;/p&gt;

&lt;p&gt;Volatile; sentiment can swing double digits in a day&lt;/p&gt;

&lt;p&gt;Premium multiple leaves less room for disappointment&lt;/p&gt;

&lt;p&gt;AI demand uncertainty&lt;/p&gt;

&lt;p&gt;Direct and concentrated exposure&lt;/p&gt;

&lt;p&gt;Exposure is real but cushioned by software and other businesses&lt;/p&gt;

&lt;p&gt;Profitability and cash flow&lt;/p&gt;

&lt;p&gt;Adjusted operating profit is small relative to interest; free cash flow is negative&lt;/p&gt;

&lt;p&gt;Strong, though free cash flow fell 27% year over year&lt;/p&gt;

&lt;p&gt;Which Stock Has Greater Upside Potential?&lt;br&gt;
We do not assign probabilities or price targets. Percentage upside depends on the price you pay and the valuation assumptions you use. The scenarios below are illustrative analysis, not predictions.&lt;/p&gt;

&lt;p&gt;CoreWeave (CRWV)&lt;br&gt;
Bull case: Backlog converts to revenue on schedule, adjusted operating margins keep widening toward the low-teens level management has pointed to, interest costs stabilize as financing gets cheaper, and new commitments keep arriving. Operating profit begins to outgrow interest expense, and the market re-rates the stock from distress to growth.&lt;/p&gt;

&lt;p&gt;Base case: Revenue keeps growing quickly and guidance is roughly met, but heavy capex and interest keep the company loss-making and dependent on capital markets. The stock stays highly volatile and trades on financing headlines as much as on operations.&lt;/p&gt;

&lt;p&gt;Bear case: Credit conditions tighten, a major customer slows spending or delays, or construction slips. The company has to raise capital on poor terms, diluting shareholders, and the thesis shifts from growth to survival of the balance sheet.&lt;/p&gt;

&lt;p&gt;Microsoft (MSFT)&lt;br&gt;
Bull case: Azure growth accelerates further (management is guiding 49–50% next quarter), Copilot and agents become meaningful revenue streams, and capex efficiency lifts free cash flow. Earnings growth justifies today’s premium multiple.&lt;/p&gt;

&lt;p&gt;Base case: Double-digit revenue and operating income growth continues, Azure stays strong, and free cash flow stays positive but pressured by capex. Returns are driven mostly by earnings growth rather than multiple expansion.&lt;/p&gt;

&lt;p&gt;Bear case: AI demand cools or competitors take share, while capex and lease commitments keep rising. Free cash flow shrinks further and the premium multiple compresses, even though the underlying business remains highly profitable.&lt;/p&gt;

&lt;p&gt;Final Verdict: CRWV vs. MSFT&lt;br&gt;
If you define upside purely as maximum percentage gain, CoreWeave has the higher ceiling. It is much smaller, growing faster, and its stock is far below its highs, so a successful execution could move the shares dramatically. If you define upside as risk-adjusted return, Microsoft has the clearer case: it is highly profitable, growing in the high teens at enormous scale, and not reliant on capital markets to fund its growth.&lt;/p&gt;

&lt;p&gt;In our view, CoreWeave is a high-risk, high-volatility bet on AI infrastructure demand and on the company’s ability to finance its buildout. Microsoft is a diversified, cash-generating way to own the same theme. Many investors who want AI infrastructure exposure may prefer to size a CoreWeave position small, if at all, and anchor the rest of their exposure in a business like Microsoft’s. This is a framework for thinking, not a recommendation.&lt;/p&gt;

&lt;p&gt;Frequently Asked Questions&lt;br&gt;
Is CoreWeave a better buy than Microsoft?&lt;/p&gt;

&lt;p&gt;It depends on your risk tolerance. CoreWeave offers more potential percentage upside but carries heavy debt, customer concentration and high volatility. Microsoft offers stability and profitability with lower upside potential.&lt;/p&gt;

&lt;p&gt;Why did CoreWeave stock fall in October 2026?&lt;/p&gt;

&lt;p&gt;Press coverage linked the sell-off to concerns about CoreWeave’s large debt load and rising borrowing costs, amplified by inflation data that raised expectations of higher interest rates. The decline spread to other debt-funded AI cloud names such as Nebius.&lt;/p&gt;

&lt;p&gt;Is Microsoft’s AI spending a risk? &lt;/p&gt;

&lt;p&gt;Yes. Capex is above $45 billion per quarter and free cash flow fell 27% last quarter. Microsoft’s profits and balance sheet give it far more room to absorb that than a smaller, leveraged company.&lt;/p&gt;

&lt;p&gt;What is CoreWeave’s backlog?&lt;/p&gt;

&lt;p&gt;About $104 billion as of June 30, 2026, plus more than $25 billion of new commitments announced for early Q3. Backlog is a contracted pipeline, not recognized revenue.&lt;/p&gt;

&lt;p&gt;When does CoreWeave report next?&lt;/p&gt;

&lt;p&gt;CoreWeave’s Q3 2026 results are expected in November; confirm the exact date on its investor relations page.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>tutorial</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Conquest's AI Financial Advice Engine Now Connects to Claude: What Advisors Need to Know</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Wed, 28 Oct 2026 13:57:46 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/conquests-ai-financial-advice-engine-now-connects-to-claude-what-advisors-need-to-know-30o3</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/conquests-ai-financial-advice-engine-now-connects-to-claude-what-advisors-need-to-know-30o3</guid>
      <description>&lt;p&gt;On October 27, 2026, Winnipeg-based Conquest announced a connector that puts its Conquest AI financial advice engine inside Claude. An advisor can ask Claude whether a client is on track for retirement, and the figures come from Conquest's planning engine rather than from the language model's own arithmetic.&lt;br&gt;
That design addresses the weak point of AI in financial planning. Chat assistants are good at drafting and summarizing, but a confident wrong number in a retirement projection is a real problem. Connecting the assistant to a system that computes the figures splits the work: the model handles conversation, and a specialist engine handles math.&lt;br&gt;
Some context on timing. Anthropic's Claude for Financial Advisors overview carries an October 27 date, notes it was first published on September 14, and says it was updated to add partner connectors. Conquest Planning is on that list.&lt;br&gt;
This article separates what Conquest and Anthropic say from what independent evidence supports. We have not tested the connector, and we found no independent benchmarks, so performance claims below are company-reported.&lt;br&gt;
What Is Conquest's AI Financial Advice Engine?&lt;br&gt;
Conquest, which says it was established in 2018, sells planning technology to banks, broker-dealers, and independent advisors. Its core product is Strategic Advice Manager (SAM), which the company calls a verifiable AI financial advice engine. Conquest says it supports more than 75% of financial advisors in Canada and that SAM has powered millions of plans. Both figures are Conquest's own and unverified.&lt;br&gt;
SAM is not a chatbot. According to Conquest, it pairs a deterministic calculation engine with a proprietary expert system built on codified planning practices. It reviews a household's financial picture, projects many candidate strategies against the plan (Conquest says hundreds), and ranks them with a cost-benefit algorithm that weighs goals, risk tolerance, and preferences. Each strategy is guardrailed by the jurisdiction's tax rules, regulatory requirements, and cash-flow affordability.&lt;br&gt;
SAM also produces a SAM Score, a single number for plan completeness and quality that updates as strategies are applied.&lt;br&gt;
Conquest is explicit that SAM is not an LLM or generative AI. It is closer to classical AI: rules and calculations, not a model that predicts text.&lt;br&gt;
What Does the Claude Integration Actually Do?&lt;br&gt;
The connector lets advisors reach SAM through natural-language conversation in Claude. Based on Conquest's announcement, connector page, and MCP page, the use cases are:&lt;br&gt;
• Retrieving client information and plan summaries. Plan details, summaries, and financial data come into the conversation. Conquest's MCP page lists income, KPIs, goals, gaps, and applied strategies.&lt;br&gt;
• Checking goal progress. An advisor can ask whether a client is on track for retirement, and Conquest says its engine runs the projections. Its example is a client asking what retirement looks like at 60 instead of 65.&lt;br&gt;
• Spotting planning opportunities. SAM ranks and verifies strategies as a client's circumstances change.&lt;br&gt;
• Creating client files and first-draft plans. Conquest describes a first draft contextualized to the client's goals, priorities, and risk tolerance.&lt;br&gt;
• Updating plans and applying strategies. Advisors can edit household details and apply a strategy from within Claude, then see the plan update. The MCP page says advisors can review, apply, modify, and remove strategies, with advisor confirmation.&lt;br&gt;
• Preparing for meetings. Conquest says Claude can pull the SAM Score, a full plan summary, and a household debrief on pacing against goals, useful before meeting a client you haven't seen in a year.&lt;br&gt;
The write actions are the notable part. This is more than a read-only lookup: the advisor can change a plan from the chat window.&lt;br&gt;
How the Technology Works&lt;br&gt;
Three layers do the work.&lt;br&gt;
• Claude is the conversational interface. It interprets the advisor's question and writes the response.&lt;br&gt;
• Model Context Protocol (MCP) is the connection. It is an open standard, introduced by Anthropic in late 2024, that lets AI applications reach outside tools and live data. Conquest compares it to a USB-C port for AI.&lt;br&gt;
• SAM is the calculation and strategy engine. It computes the numbers and ranks the strategies.&lt;br&gt;
The flow looks like this:&lt;br&gt;
Advisor question&lt;br&gt;
   → Claude&lt;br&gt;
   → MCP connector&lt;br&gt;
   → Conquest SAM&lt;br&gt;
   → Verified calculations and planning results&lt;br&gt;
   → Advisor review&lt;br&gt;
Deterministic versus generative&lt;br&gt;
A deterministic engine returns the same output for the same inputs. A generative model produces text by predicting likely words, so the same question can yield different answers, and arithmetic can go wrong.&lt;br&gt;
In this design Claude is not supposed to do the math. It calls the tool and relays the result. But Claude still writes the wording around those numbers, and Conquest itself tells advisors to review that wording before sharing it with a client.&lt;br&gt;
Why traceability matters&lt;br&gt;
An advisor who presents a projection to a client needs a defensible path from input to output. Conquest says each figure traces back to the rate, rule, or assumption behind it, and that a compliance officer or regulator can re-run a scenario with the same inputs and expect the same answer. That is what an audit trail is for.&lt;br&gt;
Why Verifiable Financial Calculations Matter&lt;br&gt;
General-purpose AI is a poor fit for long-horizon financial math. A retirement projection depends on tax rules, cash flow over decades, and assumptions about returns and inflation. Plausible-sounding output is not enough. Conquest's pages put it bluntly, saying a general chatbot will answer with confidence even when wrong. That is a vendor's framing, but the underlying concern is reasonable.&lt;br&gt;
A sound projection needs four things:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Accurate inputs. The client's data has to be right and current.&lt;/li&gt;
&lt;li&gt;Repeatable results. The same inputs should produce the same outputs.&lt;/li&gt;
&lt;li&gt;Clear assumptions. Reviewers need to see what the model assumed.&lt;/li&gt;
&lt;li&gt;Professional oversight. A qualified person has to own the conclusion.
Determinism helps with the second item and supports the third. It does not guarantee correctness. A stale client record, a questionable assumption, or a misapplied strategy would be reproduced identically every time. Conquest's own phrasing is more careful than a flat "no errors": it says any error in SAM is systematic and discoverable rather than random. That is a real advantage for debugging, but it is not a guarantee.
The language layer adds its own risks. Claude could select the wrong household or paraphrase a result loosely.
Compliance is similar. Conquest says SAM checks strategies against frameworks including CRM2/CRM3 in Canada, Best Interest and DOL Fiduciary standards in the U.S., and FCA Targeted Support in the U.K. That can support a firm's compliance process, but it does not replace it. Anthropic's own page says investment recommendations, client communications, and compliance determinations remain subject to human review and approval.
Benefits for Financial Advisors
These are intended or potential benefits. We found no independent performance data for this connector.
The motivation is time. Anthropic's page cites Kitces research indicating a typical advisory practice spends only about a sixth of its time in client meetings. Conquest's announcement cites a Financial Planning and Conquest survey, conducted June 16 to 24, 2026, in which 72% of firms said they were pursuing intelligent automation and AI initiatives. The sample was 125 wealth management professionals, and Conquest co-produced the research, so read it as directional.
Potential benefits, as Conquest and Anthropic frame them:
• Less application switching. Plan data appears where the advisor already works.
• Faster meeting prep. A plan summary and goal pacing on request instead of manual assembly.
• Easier access to existing plans. Plain-language retrieval instead of navigating screens.
• More efficient plan updates. Applying a strategy from the conversation.
• Better use of advisor time. Hours shifted from prep and data entry toward clients.
• More consistent documentation. Conquest cites audit trails behind applied strategies. Whether that improves a firm's records depends on how it is configured and reviewed.
Security, Privacy, and Compliance Considerations
Here is what Conquest says publicly:
• The connector is opt-in. Firms decide who connects, firm-wide or by user.
• Every connection is authenticated before plan data is shared.
• Regional hosting in the U.S., Canada, and the U.K. lets firms choose where data resides.
• Conquest lists ISO/IEC 42001 (AI management systems), SOC 2 Type 2, and ISO 27001.
Treat certifications as evidence of audited management systems and controls. They do not certify that a specific workflow, prompt pattern, or firm configuration is compliant. Ask for the reports and their scope.
Several questions sit outside what the pages reviewed address. Conquest's data residency applies to its own hosting, and the pages do not say how it extends to the assistant side of the conversation. Anthropic recommends Enterprise plans for registered investment advisers because they include audit logs that support recordkeeping. Firms also need to consider privacy and securities rules in each jurisdiction where they operate, such as PIPEDA in Canada or UK GDPR in the United Kingdom, and have counsel review the setup.
Limitations and Questions Firms Should Ask
Before adopting any AI-connected planning tool, put these to the vendor and to internal compliance:
• Who can access sensitive client information? Conquest says access can be firm-wide or by user. Ask how that maps to your advisor, assistant, and support roles.
• How are permissions configured? Ask who administers them, how changes are logged, and how access is revoked.
• Can advisors verify the inputs behind projections? Conquest says projections trace to inputs. Confirm what an advisor can actually see in the Claude interface versus inside Conquest.
• What records are retained for audits? Ask what is logged on each side of the connection, including prompts, tool calls, and plan changes, and for how long.
• How are incorrect or outdated client records handled? The engine will compute faithfully on bad data. Ask about data-quality checks and correction workflows.
• Which jurisdictions and frameworks are supported? Conquest names Canadian, U.S., and U.K. frameworks. Confirm that coverage matches your clients and product shelf.
• What human approval is required before advice reaches clients? Define it in policy: who reviews generated wording, and who signs off on applied strategies.
The connector is also not a self-serve switch. Conquest says existing customers should contact their account team, and its MCP page says setup involves a short process and an agreement. We found no published connector pricing.
For wider context on deploying AI inside enterprises, see our piece on what enterprise agentic AI actually delivers.
What This Means for the Future of AI in Wealth Management
The Conquest integration is one example of a broader pattern. Anthropic's announcement lists connectors to custodians, portfolio platforms, CRMs, and planning tools, including Addepar, Charles Schwab, Envestnet, and Orion. The assistant becomes a front door, and the systems of record stay behind it.
There is also a decoupling effect. Conquest says its MCP server works with Claude, ChatGPT, and Microsoft Copilot, so the engine is not tied to one assistant. That is Conquest's claim, but it follows from MCP being an open standard. For firms, it means the interface may change while the calculation layer stays the same. If you are new to the idea, our guide to AI agents explains how tool-using assistants work.
Governance is likely to become the differentiator. Conquest's connector page cites a Financial Planning 2026 finding that 40% of firms rank governance and compliance as their top priority when evaluating AI (we did not locate the underlying report).
Our read, which is a judgment and not a finding: firms will probably pilot read-only workflows such as meeting prep before trusting write actions on live plans. Wealth management will need all four ingredients together: conversational AI, reliable calculations, governance, and human judgment. Independent evaluations of tools like this are still scarce.
Bottom Line
Connecting Claude to Conquest's planning engine is a sensible architecture. It lets a language model do what it does well, which is conversation and drafting, while a deterministic engine does the math. If the claims hold up in a firm's own testing, advisors could spend less time moving between systems.
But the integration shifts risk and does not remove it. Data quality, permissions, record retention, and review of generated wording all remain the firm's job, and so does the advice itself. The advisor stays responsible to the client.
Frequently Asked Questions&lt;/li&gt;
&lt;li&gt;What is Conquest's AI financial advice engine? It is Strategic Advice Manager (SAM), which Conquest describes as a verifiable engine combining a deterministic calculation engine with an expert system to evaluate and rank planning strategies.&lt;/li&gt;
&lt;li&gt;What is Claude for Financial Advisors? Anthropic's offering for wealth management professionals: connectors to advisor tools plus workflow skills for tasks like meeting prep. Anthropic says regulated activities stay subject to human review and approval.&lt;/li&gt;
&lt;li&gt;How does the Conquest Claude integration work? An advisor asks Claude a question, Claude calls Conquest through an MCP connector, SAM computes the result, and the advisor reviews it before acting.&lt;/li&gt;
&lt;li&gt;What is Strategic Advice Manager (SAM)? Conquest's planning engine. It projects and ranks strategies against a client's plan and produces a SAM Score. Conquest says it is deterministic and is not generative AI.&lt;/li&gt;
&lt;li&gt;What is MCP in AI financial planning? Model Context Protocol is an open standard for connecting AI applications to outside data and tools. Here it is the link between Claude and Conquest's engine.&lt;/li&gt;
&lt;li&gt;Can Claude create and update financial plans through Conquest? According to Conquest, yes. Advisors can create client files and first-draft plans, edit household details, and apply strategies. Its MCP page says strategy changes involve advisor confirmation.&lt;/li&gt;
&lt;li&gt;How does Conquest make financial projections verifiable? Conquest says the same inputs return the same outputs and that each figure traces to its inputs with an audit trail. Verification still depends on clean inputs and human review.&lt;/li&gt;
&lt;li&gt;Does this integration replace human financial advisors? No. Both Conquest and Anthropic frame it as supporting advisor judgment, and the advisor remains responsible for advice given to clients.&lt;/li&gt;
&lt;li&gt;What security and compliance considerations should firms review? Access controls, authentication, data residency, record retention, jurisdiction coverage, certification scope (ISO/IEC 42001, SOC 2 Type 2, ISO 27001 per Conquest), and the firm's own approval workflow.&lt;/li&gt;
&lt;li&gt;Is the Conquest connector available now? Conquest says it is available now in Anthropic's connector directory. Existing customers are directed to their Conquest account team to activate it, and its MCP page says setup requires an agreement. Check both companies' pages for current terms.&lt;/li&gt;
&lt;/ol&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
    <item>
      <title>leanrea: An 8 KB Skill That Replaces the REA MCP Server, Claimed vs Verified</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Fri, 23 Oct 2026 07:15:27 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/leanrea-an-8-kb-skill-that-replaces-the-rea-mcp-server-claimed-vs-verified-4125</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/leanrea-an-8-kb-skill-that-replaces-the-rea-mcp-server-claimed-vs-verified-4125</guid>
      <description>&lt;p&gt;Introduction: Why leanrea Is Getting Attention&lt;/p&gt;

&lt;p&gt;leanrea is a compact coding-agent skill designed to guide reverse-engineering work through ordinary command-line utilities instead of requiring the agent to interact with REA’s full Model Context Protocol (MCP) tool layer. Its central idea is simple: when a coding agent already has shell access and the right utilities are installed, a short set of well-organized instructions may be enough to route common investigations efficiently.&lt;/p&gt;

&lt;p&gt;The project has attracted attention because its author reports that an approximately 8 KB skill completed a small benchmark faster and at lower cost than REA, while scoring almost as highly. That is an interesting result, but it needs context. A benchmark across a limited set of tasks is evidence about those tasks and that environment—not proof that leanrea is universally better or that REA is unnecessary.&lt;/p&gt;

&lt;p&gt;This review separates the repository’s claims from what the published benchmark can reasonably establish. It also examines a practical distinction that is easy to miss: leanrea is primarily an instruction layer, while REA is a larger MCP server and CLI system. They overlap in some workflows, but they are not identical products.&lt;/p&gt;

&lt;p&gt;What Is leanrea?&lt;/p&gt;

&lt;p&gt;leanrea is an open-source skill file that tells an AI coding agent how to approach common reverse-engineering tasks. Rather than exposing a large collection of specialized MCP tools, it maps target types to direct shell commands, suggests efficient first-pass checks, and documents pitfalls that can lead to incomplete or misleading results.&lt;/p&gt;

&lt;p&gt;The repository describes the skill as roughly 8 KB. It includes routing guidance for targets such as Electron applications, minified web bundles, Mach-O binaries, Go and Rust executables, .NET assemblies, Android packages, Flutter artifacts, WebAssembly, SQLite files, packet captures, firmware, and websites. The exact result still depends on what the target contains and which tools are available on the machine.&lt;/p&gt;

&lt;p&gt;A skill is not the same thing as an analysis engine. leanrea does not, by itself, install tools such as Ghidra, JADX, Hopper, apktool, binwalk, or platform-specific utilities. It guides the agent toward tools it can already run. If a required utility is missing, the agent may need setup help or a different analysis path.&lt;/p&gt;

&lt;p&gt;How leanrea Works Under the Hood&lt;/p&gt;

&lt;p&gt;Choose an authorized target. Work only with software, binaries, captures, or systems that you own or are permitted to inspect. Make a copy when appropriate and preserve the original artifact.&lt;/p&gt;

&lt;p&gt;Identify the target type. Determine the file format using metadata and magic bytes rather than relying only on the filename. This helps avoid applying an unsuitable toolchain.&lt;/p&gt;

&lt;p&gt;Route to relevant utilities. The skill recommends direct commands for the target—for example, ASAR extraction and ripgrep for Electron bundles, macOS inspection tools for Mach-O files, or Go’s own build-information command for Go binaries.&lt;/p&gt;

&lt;p&gt;Batch initial reconnaissance. Instead of asking the agent to call many separate wrappers, leanrea encourages combining related checks into a focused shell call where practical. This can reduce tool round trips and avoid flooding the context with irrelevant output.&lt;/p&gt;

&lt;p&gt;Inspect targeted evidence. Search for relevant strings, imports, symbols, call sequences, metadata, or code paths. Avoid dumping entire minified files or huge JSON outputs into the conversation.&lt;/p&gt;

&lt;p&gt;Report evidence carefully. The skill encourages labeling claims as seen, inferred, or unknown. This helps distinguish direct observations from interpretations and from information that has not been established.&lt;/p&gt;

&lt;p&gt;For example, a developer investigating an Electron application might extract its ASAR archive and search bundled code for an IPC channel or feature handler. A Go executable may expose compiler and dependency metadata through &lt;code&gt;go version -m&lt;/code&gt;. A macOS binary may be inspected with tools such as &lt;code&gt;otool&lt;/code&gt;, &lt;code&gt;nm&lt;/code&gt;, or other available platform utilities. These are examples of the workflow described by the project, not a guarantee that every target can be fully understood with one command.&lt;/p&gt;

&lt;p&gt;leanrea vs REA MCP Server: Key Differences&lt;/p&gt;

&lt;p&gt;Area&lt;/p&gt;

&lt;p&gt;leanrea&lt;/p&gt;

&lt;p&gt;REA&lt;/p&gt;

&lt;p&gt;Architecture&lt;/p&gt;

&lt;p&gt;A compact skill/instruction file; agent uses its shell.&lt;/p&gt;

&lt;p&gt;A broader MCP server and CLI that exposes specialized operations.&lt;/p&gt;

&lt;p&gt;Installation footprint&lt;/p&gt;

&lt;p&gt;Repository describes one SKILL.md of about 8 KB.&lt;/p&gt;

&lt;p&gt;Repository benchmark compares against an npm package and MCP setup; reported package footprint is larger.&lt;/p&gt;

&lt;p&gt;MCP server&lt;/p&gt;

&lt;p&gt;Not required for the skill’s intended workflow.&lt;/p&gt;

&lt;p&gt;MCP is a core way REA exposes tools to compatible agents.&lt;/p&gt;

&lt;p&gt;Tool exposure&lt;/p&gt;

&lt;p&gt;Adds no new MCP tools; relies on normal shell access.&lt;/p&gt;

&lt;p&gt;Exposes a large tool catalogue; repository reports 207 tools for the tested version.&lt;/p&gt;

&lt;p&gt;Command-line dependencies&lt;/p&gt;

&lt;p&gt;Relevant utilities must be available locally.&lt;/p&gt;

&lt;p&gt;REA routes through its infrastructure and may still rely on external analysis engines for deeper tasks.&lt;/p&gt;

&lt;p&gt;Analysis workflow&lt;/p&gt;

&lt;p&gt;Instructions select direct commands and focused follow-up checks.&lt;/p&gt;

&lt;p&gt;Provides structured operations through its MCP/CLI interface.&lt;/p&gt;

&lt;p&gt;Evidence and output&lt;/p&gt;

&lt;p&gt;Agent interprets command output; skill asks for seen/inferred/unknown distinctions.&lt;/p&gt;

&lt;p&gt;Provides a more integrated tool interface; exact output depends on the operation and version.&lt;/p&gt;

&lt;p&gt;Context overhead&lt;/p&gt;

&lt;p&gt;Small instruction file; no large MCP catalogue added by the skill.&lt;/p&gt;

&lt;p&gt;Can add tool-definition overhead, though selective/deferred tool loading can reduce this.&lt;/p&gt;

&lt;p&gt;Portability&lt;/p&gt;

&lt;p&gt;Potentially portable across agents that support skills and shell access.&lt;/p&gt;

&lt;p&gt;Requires a compatible MCP/CLI setup and its supported runtime environment.&lt;/p&gt;

&lt;p&gt;Best fit&lt;/p&gt;

&lt;p&gt;Common investigations where direct tools already exist and the agent can use them.&lt;/p&gt;

&lt;p&gt;Workflows that benefit from REA’s integrated tool layer, supported operations, or repeatable interfaces.&lt;/p&gt;

&lt;p&gt;Main limitation&lt;/p&gt;

&lt;p&gt;Does not independently install tools or provide a full analysis engine.&lt;/p&gt;

&lt;p&gt;More setup and interface overhead; results still depend on installed engines and target characteristics.&lt;/p&gt;

&lt;p&gt;The important distinction is not “skill good, MCP bad.” MCP can be useful when an agent needs a stable interface, structured operations, or tools that are not naturally available in a shell. leanrea’s argument is narrower: where the agent already has shell access and the right utilities, an extra wrapper may not always improve the outcome.&lt;/p&gt;

&lt;p&gt;leanrea Benchmark Results: Claimed vs Verified&lt;/p&gt;

&lt;p&gt;The official leanrea repository reports a benchmark using Claude Code in headless mode, with four reverse-engineering tasks, three repetitions per task for each of three setups, and 36 runs in total. The setups were leanrea, REA with its MCP server and skill documentation, and a no-skill baseline. Answers were graded against manually prepared answer keys.&lt;/p&gt;

&lt;p&gt;Metric&lt;/p&gt;

&lt;p&gt;leanrea&lt;/p&gt;

&lt;p&gt;REA&lt;/p&gt;

&lt;p&gt;No skill&lt;/p&gt;

&lt;p&gt;Wall-clock time&lt;/p&gt;

&lt;p&gt;388 seconds&lt;/p&gt;

&lt;p&gt;627 seconds&lt;/p&gt;

&lt;p&gt;479 seconds&lt;/p&gt;

&lt;p&gt;Reported cost&lt;/p&gt;

&lt;p&gt;$2.17&lt;/p&gt;

&lt;p&gt;$3.36&lt;/p&gt;

&lt;p&gt;$2.21&lt;/p&gt;

&lt;p&gt;Agent turns&lt;/p&gt;

&lt;p&gt;55&lt;/p&gt;

&lt;p&gt;124&lt;/p&gt;

&lt;p&gt;81&lt;/p&gt;

&lt;p&gt;Score&lt;/p&gt;

&lt;p&gt;74/75&lt;/p&gt;

&lt;p&gt;75/75&lt;/p&gt;

&lt;p&gt;67/75&lt;/p&gt;

&lt;p&gt;What the numbers suggest&lt;/p&gt;

&lt;p&gt;Compared with REA in this test, leanrea was reported to use about 38% less wall-clock time, 35% lower cost, 56% fewer agent turns, and 60% fewer tokens. It scored 74 out of 75, compared with REA’s 75 out of 75. The no-skill baseline scored 67 out of 75, cost $2.21, and finished in 479 seconds.&lt;/p&gt;

&lt;p&gt;The baseline matters. It suggests that a capable model with ordinary shell access can already complete much of the tested work without either setup. leanrea’s reported gain over the baseline was more modest than its gain over REA on time and turns, and the baseline’s cost was close to leanrea’s. So the benchmark supports a specific claim about efficiency in the tested environment—not the broader claim that every agent needs leanrea.&lt;/p&gt;

&lt;p&gt;What is verified, and what remains unproven?&lt;/p&gt;

&lt;p&gt;Repository-reported: The table above, the task descriptions, the benchmark scripts and the author’s interpretation are published by the leanrea project. They can be inspected and the project provides instructions intended to reproduce the test.&lt;/p&gt;

&lt;p&gt;Not an independent replication: The headline figures should be described as author-reported unless an independent party reproduces the same tasks, versions, environment, model settings, and scoring procedure. Other articles that repeat the same table are not independent validation by themselves.&lt;/p&gt;

&lt;p&gt;Small sample size: Three repetitions per task and setup are useful for an initial comparison, but too few to establish broad performance guarantees across diverse targets and agent configurations.&lt;/p&gt;

&lt;p&gt;Environment-specific: The results depend on the chosen model, machine, operating system, tools installed, target artifacts, and agent configuration. The repository notes that some specialist tools were not installed for the test.&lt;/p&gt;

&lt;p&gt;One score difference: The project says leanrea’s single partial miss involved naming an older version of an IPC channel where two versions existed. This is the author’s explanation of the result, not evidence that all future tasks will have the same accuracy gap.&lt;/p&gt;

&lt;p&gt;The Context-Overhead Claim Needs Qualification&lt;/p&gt;

&lt;p&gt;The repository also describes a separate “reply OK” context-overhead probe. When all REA tool definitions were loaded at once, the project reports a much larger token footprint than the leanrea skill or the no-skill baseline. This illustrates a real architectural risk: large tool catalogues can consume context before useful analysis begins if an agent eagerly loads every definition.&lt;/p&gt;

&lt;p&gt;However, the same project notes that Claude Code’s deferred tool search can load MCP tools on demand. Under that configuration, the overhead is substantially lower. The correct conclusion is therefore conditional: tool-catalogue overhead can be severe in eager-loading setups, but it is not necessarily severe in agents that support selective tool discovery. Avoid repeating the largest context and cost figures without clearly stating the loading configuration and test conditions.&lt;/p&gt;

&lt;p&gt;Installation Guide: How to Try leanrea&lt;/p&gt;

&lt;p&gt;The official repository currently documents installation through the skills CLI. Check the repository before running commands because installation conventions and supported agent targets can change.&lt;/p&gt;

&lt;p&gt;Standard install&lt;/p&gt;

&lt;p&gt;npx skills add aicodeking/leanrea&lt;/p&gt;

&lt;p&gt;Install for Claude Code only, without interactive prompts&lt;/p&gt;

&lt;p&gt;npx skills add aicodeking/leanrea -a claude-code -y&lt;/p&gt;

&lt;p&gt;Install at user level&lt;/p&gt;

&lt;p&gt;npx skills add aicodeking/leanrea -g&lt;/p&gt;

&lt;p&gt;Update later&lt;/p&gt;

&lt;p&gt;npx skills update leanrea&lt;/p&gt;

&lt;p&gt;The installer may ask which agent environments should receive the skill. Review the destination and any proposed changes rather than assuming the installer configured every tool. After installation, open a fresh agent session if the skill does not appear, and verify that the agent recognizes the skill command.&lt;/p&gt;

&lt;p&gt;A manual option documented by the repository is to clone the project and copy its skill directory into the relevant Claude Code skills location. If using a different agent, follow that agent’s current skill-installation documentation.&lt;/p&gt;

&lt;p&gt;Dependencies and Compatibility: What to Check First&lt;/p&gt;

&lt;p&gt;Confirm that your agent supports skills or a comparable project-instructions mechanism, and that it has shell access.&lt;/p&gt;

&lt;p&gt;Check which target-specific utilities are already installed. Examples can include Node.js/ASAR tooling, ripgrep, Apple command-line inspection tools, JADX, apktool, Ghidra, binwalk, tshark, or sqlite3 depending on the artifact.&lt;/p&gt;

&lt;p&gt;Do not assume every listed target type is fully analyzable on every operating system. Some commands are platform-specific, and deeper analysis may require separately installed applications.&lt;/p&gt;

&lt;p&gt;Use a test artifact you are authorized to inspect. Keep the original unchanged and be cautious when running unfamiliar binaries or scripts.&lt;/p&gt;

&lt;p&gt;Inspect the current README and LICENSE in the repository before distributing, modifying, or incorporating the skill into a product.&lt;/p&gt;

&lt;p&gt;Where leanrea May Be a Good Fit&lt;/p&gt;

&lt;p&gt;Quick reconnaissance: You want to identify file formats, dependencies, imports, strings, metadata, or likely entry points without setting up a larger tool integration.&lt;/p&gt;

&lt;p&gt;Electron and bundled JavaScript: You need to extract an archive and search code efficiently, while avoiding unnecessarily large output in the model context.&lt;/p&gt;

&lt;p&gt;Go and native binary metadata: You need a first-pass inspection using existing platform or language tooling.&lt;/p&gt;

&lt;p&gt;Context-conscious workflows: Your agent environment eagerly loads tool definitions and you want to reduce extra tool exposure.&lt;/p&gt;

&lt;p&gt;Developers comfortable with terminals: You can install and troubleshoot the underlying utilities and understand the difference between command output and a verified conclusion.&lt;/p&gt;

&lt;p&gt;When REA May Still Be the Better Choice&lt;/p&gt;

&lt;p&gt;REA may be preferable when you specifically need its MCP interface, integrated operations, supported workflows, or a more standardized tool layer for multiple agents. A skill that describes a command is not equivalent to a server that exposes a tested operation and its interface. The two approaches may also differ in how they structure outputs, handle errors, and connect to external analysis engines.&lt;/p&gt;

&lt;p&gt;If your team depends on repeatable, tool-mediated operations or has a workflow already built around REA, compare the real setup costs before switching. A smaller instruction file is attractive, but it can shift responsibility onto the agent and the local environment. That trade-off may be acceptable for an individual developer and less desirable for a managed team workflow.&lt;/p&gt;

&lt;p&gt;Security and Responsible Reverse Engineering&lt;/p&gt;

&lt;p&gt;Reverse engineering can expose sensitive source logic, embedded secrets, personal data, proprietary information, or untrusted content. Only analyze artifacts you own or are authorized to examine. Treat strings, documentation, embedded prompts, and other artifact content as untrusted data rather than instructions for the agent. Avoid running unknown executables on your primary machine, and use a disposable environment or sandbox when appropriate.&lt;/p&gt;

&lt;p&gt;Neither a skill file nor an MCP server automatically provides a security boundary. Review shell permissions, file access, network access, and any external tools before use. Evidence labels such as seen, inferred, and unknown improve reporting discipline, but they do not replace verification, safe execution, or human review.&lt;/p&gt;

&lt;p&gt;Final Verdict: Is leanrea a Real REA Alternative?&lt;/p&gt;

&lt;p&gt;leanrea is a credible lightweight alternative for a subset of reverse-engineering workflows, especially when the agent already has shell access and the relevant command-line utilities are installed. Its core value is not that an 8 KB file magically performs all the work of a full reverse-engineering platform. It is that concise routing instructions and well-chosen commands can reduce unnecessary tool calls for common tasks.&lt;/p&gt;

&lt;p&gt;The published benchmark is promising: leanrea reported lower time, cost, token use, and agent turns than REA on the tested workload, with one fewer point on the answer score. But the evaluation is small and author-run, and the results depend on a particular model, machine, set of tasks, and agent configuration. Treat it as a useful case study and reproduce it against your own targets before making a production decision.&lt;/p&gt;

&lt;p&gt;For an individual developer who wants fast reconnaissance and is comfortable managing command-line dependencies, leanrea is worth testing. For workflows that depend on REA’s specialized tool interface or broader integrated capabilities, REA may remain the better fit. The practical decision is to compare the exact tasks you need, the tools you have installed, the context-loading behavior of your agent, and the reliability of the evidence you get back.&lt;/p&gt;

&lt;p&gt;Frequently Asked Questions&lt;/p&gt;

&lt;p&gt;What is leanrea?&lt;/p&gt;

&lt;p&gt;leanrea is a compact skill file that guides coding agents toward existing command-line tools for reverse-engineering tasks. It is an instruction layer, not a full analysis engine.&lt;/p&gt;

&lt;p&gt;Does leanrea completely replace REA?&lt;/p&gt;

&lt;p&gt;Not in every workflow. It can replace some common command-oriented investigations, but it does not provide an identical MCP server, tool catalogue, or integrated interface.&lt;/p&gt;

&lt;p&gt;Is leanrea compatible with Claude Code?&lt;/p&gt;

&lt;p&gt;The repository documents installation through the skills CLI, including a Claude Code-specific option. Check the current README for up-to-date agent support.&lt;/p&gt;

&lt;p&gt;Does leanrea install Ghidra or JADX?&lt;/p&gt;

&lt;p&gt;No. The skill does not automatically install every external utility. Target-specific tools must be available separately when needed.&lt;/p&gt;

&lt;p&gt;Are the benchmark results independently verified?&lt;/p&gt;

&lt;p&gt;The published figures are author-reported. The repository provides reproduction material, but the numbers should not be called independently verified unless a separate reproduction is documented.&lt;/p&gt;

&lt;p&gt;Why might leanrea be faster?&lt;/p&gt;

&lt;p&gt;Its approach can reduce wrapper calls and large intermediate outputs by using direct commands and batching related checks. The advantage depends on the target and agent configuration.&lt;/p&gt;

&lt;p&gt;Is REA still useful if an agent supports tool search?&lt;/p&gt;

&lt;p&gt;Yes, potentially. Selective tool loading can reduce the context cost of a large MCP catalogue, so the trade-off should be evaluated in the actual agent environment.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Earshot: An Open-Source Toolkit That Lets Coding Agents Hear Audio</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Tue, 20 Oct 2026 14:46:28 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/earshot-an-open-source-toolkit-that-lets-coding-agents-hear-audio-dlk</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/earshot-an-open-source-toolkit-that-lets-coding-agents-hear-audio-dlk</guid>
      <description>&lt;p&gt;What Is the Earshot Open-Source Toolkit?&lt;br&gt;
Earshot is a Python toolkit described as "ears for coding agents: let AI hear, review and make sound." It is MIT-licensed, CPU-only, and available as a CLI, a Python API, and an MCP server. It was released publicly in mid-October 2026 by developer Leon Lin (@LexnLin), who introduced it in a thread on X on October 15. The official source is the Earshot GitHub repository.&lt;br&gt;
In practice, Earshot can:&lt;br&gt;
Describe and classify audio with sound labels and measurements.&lt;br&gt;
Match a file against a text description.&lt;br&gt;
Find specific sound events inside longer recordings.&lt;br&gt;
Analyze audio alongside video, including sync to picture cuts.&lt;br&gt;
Evaluate sound design against a profile of professional launch films.&lt;br&gt;
Generate sounds in code (forge) and convert recordings into editable code (fit).&lt;br&gt;
Plug into coding agents such as Claude Code via MCP.&lt;br&gt;
Why Do AI Coding Agents Need Audio Analysis?&lt;br&gt;
Writing audio code is not the same as knowing how it sounds. Without listening, an agent has no feedback loop. Earshot also gives agents something richer than transcripts or file metadata to reason about. Practical cases:&lt;br&gt;
Checking whether a generated keyboard sound feels realistic.&lt;br&gt;
Finding sound effects that match a scene.&lt;br&gt;
Catching timing problems between sound and picture.&lt;br&gt;
Comparing generated sounds with reference recordings.&lt;br&gt;
Improving sound effects through iterative testing.&lt;br&gt;
Key Features of Earshot&lt;br&gt;
Feature&lt;br&gt;
What It Does&lt;br&gt;
Practical Use Case&lt;br&gt;
earshot describe&lt;br&gt;
Describes a file with calibrated tags, AudioSet labels, and measurements&lt;br&gt;
Confirm a generated sound is what you intended&lt;br&gt;
earshot match&lt;br&gt;
Scores how well a text description fits the audio (strong, plausible, weak, no match)&lt;br&gt;
Check that a sound fits "a deep thocky keyboard press"&lt;br&gt;
earshot rank&lt;br&gt;
Sorts many candidate files by a description&lt;br&gt;
Pick the best of several downloaded effects&lt;br&gt;
earshot find&lt;br&gt;
Finds the best matching moments as start and end trims&lt;br&gt;
Extract one clean key press from a long recording&lt;br&gt;
earshot compare / ab&lt;br&gt;
Finds nearest references; compares two sounds in words&lt;br&gt;
See how a generated sound differs from a reference&lt;br&gt;
earshot realness&lt;br&gt;
Estimates real or pro-produced versus code-synthesized&lt;br&gt;
Check whether a sound reads as synthetic&lt;br&gt;
earshot timeline&lt;br&gt;
Listening transcript with events, loudness, beat grid, and sync to cuts&lt;br&gt;
Review a film's audio second by second&lt;br&gt;
earshot sheet&lt;br&gt;
Annotated PNG of events, spectrogram, waveform, and loudness&lt;br&gt;
Give image-reading agents a visual of the audio&lt;br&gt;
earshot critique&lt;br&gt;
Scores a video against a profile of seven professional launch films&lt;br&gt;
Review a product demo's sound design&lt;br&gt;
earshot measure&lt;br&gt;
Model-free measurements: LUFS, true peak, LRA, spectrum, tempo and key&lt;br&gt;
Check loudness before export&lt;br&gt;
earshot forge&lt;br&gt;
Generates sounds from synthesis recipes and improves them through a scoring loop&lt;br&gt;
Build a keypress, whoosh, or UI click in code&lt;br&gt;
earshot fit&lt;br&gt;
Listens to a recording and writes an editable Python recipe that recreates it&lt;br&gt;
Turn a reference sound into tweakable code&lt;br&gt;
earshot gallery&lt;br&gt;
Builds a static HTML gallery of generated sound variations&lt;br&gt;
Audition many forge outputs in a browser&lt;br&gt;
earshot mcp&lt;br&gt;
Exposes the tools as an MCP server&lt;br&gt;
Connect Earshot to Claude Code&lt;br&gt;
earshot doctor&lt;br&gt;
Checks the install, models, and CPU settings&lt;br&gt;
Troubleshoot setup&lt;/p&gt;

&lt;p&gt;Every command prints a plain-language summary first. The --json flag returns the full result and --out f.json saves it.&lt;br&gt;
What's New in Version 0.2.0&lt;br&gt;
The 0.2.0 release (October 16) added earshot fit and Forge v2. According to the release notes, the library of generated effects grew from 5 types (15 sounds) to 34 types (183 sounds) covering motion-design staples: whooshes, risers, impacts, sub drops, logo stings, UI clicks, toggles, pops, dings, shimmers, typing, and glitches. It also added a held-out benchmark, a sharper critic, a faster search, and earshot gallery. The release notes report that on 12 real recordings, fit renders reached a median CLAP similarity of 0.945. That is the developer's own measurement, so treat it as indicative, not as independent proof.&lt;br&gt;
How Earshot Works&lt;br&gt;
You supply an audio file or video.&lt;br&gt;
Earshot analyzes it with machine-learning models plus signal measurements.&lt;br&gt;
It returns evidence: descriptions, scores, timestamps, or a scorecard.&lt;br&gt;
The coding agent acts on that evidence, for example by adjusting a recipe or moving an effect.&lt;br&gt;
The loop repeats until the result improves.&lt;br&gt;
Three components do the analysis:&lt;br&gt;
CLAP audio-text embeddings (laion/larger_clap_general) place audio and text in a shared space, which makes "does this sound match this sentence?" answerable.&lt;br&gt;
The AudioSet classifier (MIT/ast-finetuned-audioset-10-10-0.4593) assigns labels from the AudioSet ontology.&lt;br&gt;
Model-free measurements such as loudness, true peak, envelope, and spectrum do not depend on any model and act as a cross-check.&lt;br&gt;
That cross-check matters because forge optimizes against Earshot's own models. The README warns that a sound can please the models without truly improving (a Goodhart effect), and recommends judging results with model-free measurements, spectrograms next to references, and human listening.&lt;br&gt;
How to Install Earshot&lt;br&gt;
Prerequisites: Python 3.10 or newer, Git, FFmpeg and FFprobe on PATH, and about 1.4 GB of disk space for model downloads.&lt;br&gt;
Step 1: Clone the repository and create a virtual environment.&lt;br&gt;
git clone &lt;a href="https://github.com/Leonxlnx/earshot" rel="noopener noreferrer"&gt;https://github.com/Leonxlnx/earshot&lt;/a&gt; &amp;amp;&amp;amp; cd earshot&lt;br&gt;
python -m venv .venv&lt;br&gt;
Step 2: Install CPU-only PyTorch, then Earshot. README calls the virtual environment's Python directly. On macOS and Linux that is .venv/bin/python; on Windows use .venv/Scripts/python.&lt;br&gt;
.venv/bin/python -m pip install torch --index-url &lt;a href="https://download.pytorch.org/whl/cpu" rel="noopener noreferrer"&gt;https://download.pytorch.org/whl/cpu&lt;/a&gt;&lt;br&gt;
.venv/bin/python -m pip install -e ".[mcp,llm,dev]"&lt;br&gt;
If you prefer to activate the environment, use source .venv/bin/activate on macOS and Linux, or .venv\Scripts\activate on Windows, then run python -m pip. Check the README if a command differs on your system.&lt;br&gt;
Step 3: Run the diagnostic.&lt;br&gt;
.venv/bin/python -m earshot doctor --load&lt;br&gt;
The doctor command checks the install, models, data files, and CPU settings. The first model downloads two open models (about 1.4 GB) into .cache/hf inside the repo, or into EARSHOT_HOME. After that, Earshot works offline. Optional environment variables: EARSHOT_THREADS, EARSHOT_HOME, EARSHOT_PRECISION, and EARSHOT_OFFLINE=1.&lt;br&gt;
Speed note: each CLI call is a new process and loads the models first (the README says roughly 20 to 40 seconds). For more than a few calls, use the MCP server or a single Python script.&lt;br&gt;
How to Use Earshot: Practical Examples&lt;br&gt;
These examples assume the earshot command is available in your environment. Otherwise use python -m earshot with your virtual environment's Python.&lt;br&gt;
Example A: Describe a file&lt;br&gt;
earshot describe sound.wav&lt;br&gt;
Returns what the file sounds like: envelope shape, closest tags, and measurements. Use case: checking that a generated "keyboard click" reads as one.&lt;br&gt;
Example B: Match a description&lt;br&gt;
earshot match sound.wav "a deep mechanical keyboard press"&lt;br&gt;
Returns a verdict from strong to no match, with evidence. Add --alts to compare against competing descriptions. Use case: validating a sound before it goes into a mix.&lt;br&gt;
Example C: Find a sound in a recording&lt;br&gt;
earshot find recording.wav "a single keyboard key press" --top 4&lt;br&gt;
Returns time ranges you can use as trims. Use case: pulling one clean key press from a minute of typing.&lt;br&gt;
Example D: Critique a video&lt;br&gt;
earshot critique film.mp4&lt;br&gt;
Returns a verdict and timestamped fixes ordered by severity. Use case: reviewing a product demo. The scorecard reflects the style of its seven reference films, not every good film.&lt;br&gt;
Example E: Turn a recording into editable code&lt;br&gt;
earshot fit sound.wav -o recipe.py&lt;br&gt;
Writes a readable Python recipe with knobs for new variations. Use case: making ten variants of a click from one reference. Licensing note: a recipe fitted to a recording stays tied to that recording's licence, so do not assume fitted code is free to use commercially.&lt;br&gt;
Example F: Browse generated sounds&lt;br&gt;
earshot gallery output_directory -o gallery.html&lt;br&gt;
Builds a static HTML gallery of sound variations. Use case: auditioning forge outputs side by side. Confirm the exact flags with the earshot gallery --help.&lt;br&gt;
Bonus: generate a sound with forge&lt;br&gt;
earshot forge&lt;br&gt;
earshot forge whoosh --target "a fast crisp air whoosh" --refs path/to/real/whooshes/ --dir made/whoosh&lt;br&gt;
The forge command synthesizes candidates from physical-modeling recipes, scores them with a criterion built from Earshot's own analysis, and keeps the best through an evolutionary search. Output is a set of WAV files plus a report.json with every candidate's parameters and scores.&lt;br&gt;
How to Connect Earshot to Claude Code Using MCP&lt;br&gt;
The Model Context Protocol (MCP) is an open standard that lets AI clients call external tools. Running earshot mcp exposes Earshot's functions to a compatible client such as Claude Code.&lt;br&gt;
claude mcp add earshot --scope user -e EARSHOT_THREADS=3 -- /absolute/path/to/earshot/.venv/bin/python -m earshot mcp&lt;br&gt;
On Windows, point to the virtual environment's Windows interpreter, for example ...\earshot.venv\Scripts\python.exe, rather than copying the Unix path. You can also configure it in a .mcp.json file:&lt;br&gt;
{"mcpServers": {"earshot": {"command": "/path/to/earshot/.venv/bin/python",&lt;br&gt;
  "args": ["-m", "earshot", "mcp"], "env": {"EARSHOT_THREADS": "3"}}}}&lt;br&gt;
Why the absolute path matters: the client launches the server itself, without your virtual environment activated, so the full path guarantees the right interpreter and dependencies.&lt;br&gt;
Verifying the setup: run Claude mcp list, or check /mcp inside Claude Code. Models load on the first call and then stay in memory, which avoids the CLI's per-call startup cost. On slow machines, start Claude Code with MCP_TIMEOUT=60000.&lt;br&gt;
What the agent can do: describe a generated sound, match it to a target, rank candidates, find trims, and re-run after each change. The repository also ships two agent skills (skills/earshot and skills/real-sound) that you can copy into ~/.claude/skills/. The optional llm_critique tool reads GEMINI_API_KEY from the environment; never write a literal key into a file.&lt;br&gt;
Limitations and Alternatives&lt;br&gt;
Limitations:&lt;br&gt;
Brand-new project. Released October 15, 2026, with version 0.2.0 a day later. Expect fast change and rough edges.&lt;br&gt;
Small evidence base. The author's blind test (8 of 15 correct, essentially chance) is one listener and 15 trials, and the README says so. Independent coverage has also noted that the evidence is small.&lt;br&gt;
Models are imperfect. Loudness, timing, sync, and "is this the kind of sound I asked for" on exposed sounds are reliable. Tags inside busy mixes, music genre, and mood are hints only.&lt;br&gt;
Self-scoring bias. Generated sounds are judged by Earshot's own critic, so human review is still needed.&lt;br&gt;
No judgment of taste, emotion, speech content, or licences.&lt;br&gt;
Startup and memory cost. Local models use RAM, and CLI calls have cold starts.&lt;br&gt;
Licensing of fitted code (see Example E).&lt;br&gt;
See the repository's LIMITS.md and VALIDATION.md for details.&lt;br&gt;
Alternatives: FFmpeg covers loudness and format work, librosa covers spectral analysis, and CLAP or AudioSet models can be called directly. Earshot's value is packaging these into an agent-friendly workflow with plain-language output.&lt;br&gt;
Conclusion&lt;br&gt;
The Earshot open-source toolkit gives coding agents a way to hear what they build. Through its CLI, Python API, and Claude Code MCP integration, it can describe sounds, match them to text, locate events, critique video sound design, generate synthetic audio, and convert recordings into editable code, all on a local CPU. It is young, fast-moving, and open about its limits, but for developers building games, films, or demos with AI agents it is a practical place to start. Install it from the Earshot GitHub repository, run doctor --load, and try an earshot described on a file you care about.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Claude Code allow_large: Read Large Files (2026 Guide)</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Sun, 18 Oct 2026 07:01:41 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/claude-code-allowlarge-read-large-files-2026-guide-553i</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/claude-code-allowlarge-read-large-files-2026-guide-553i</guid>
      <description>&lt;p&gt;Claude Code allow_large: How to Read Large Files&lt;br&gt;
You ask Claude Code to review a big generated file or a long log, and it returns only the top part. Or it tells you to read the file in portions. That is the Read tool's size limits at work. Since Claude Code v2.1.296 (released October 9, 2026), the Read tool has an option built for this case: allow_large.&lt;br&gt;
This guide explains what Claude Code allow_large does, how default file reading works, how to get Claude to use it, and when offset, limit, a search, or a subagent is the better choice. Everything marked as documented comes from Anthropic's official Claude Code documentation and changelog. Third-party reports are labeled as such.&lt;br&gt;
Prefer video? The Hustle to AI channel covers the same topic here: &lt;a href="https://www.youtube.com/watch?v=KrxZ7cRqWNU" rel="noopener noreferrer"&gt;https://www.youtube.com/watch?v=KrxZ7cRqWNU&lt;/a&gt;&lt;br&gt;
What Is allow_large in Claude Code?&lt;br&gt;
allow_large is an optional input on Claude Code's Read tool. The changelog describes it as letting Claude read a text file past the usual size limits in one call when it needs the whole file and the context has room. The official tools reference adds that Claude can read the whole file, or a long line range, in one call by setting allow_large to true. That read is sized against the room left in the session's context window instead of the default limits.&lt;br&gt;
In plain terms: normally one Read call returns a limited amount of a file. With allow_large, Claude can ask for far more in one go, as long as your context window can hold it.&lt;br&gt;
What to know before you rely on it:&lt;br&gt;
Claude sets it, not you. The docs describe Claude setting allow_large: true when it needs to, for example because you asked for the entire file. I found no documented command-line flag or settings key that turns it on.&lt;br&gt;
It needs v2.1.296 or later. Older versions do not have the option.&lt;br&gt;
It applies to text files. Images, PDFs, and notebooks keep their own limits.&lt;br&gt;
The context window is the real ceiling. The documentation does not state a fixed maximum file size for an allow_large read, so a file larger than your remaining context still cannot fit.&lt;br&gt;
How Claude Code Handles Large Files&lt;br&gt;
A file existing on disk does not mean Claude can see all of it in one response. Whatever Read returns goes into the model's context window, which is shared with your conversation, instructions, and earlier tool results. Default limits stop one careless read from filling it.&lt;br&gt;
The documented defaults are:&lt;br&gt;
One Read call returns at most 25,000 tokens by default. The CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS environment variable can change this value.&lt;br&gt;
A whole-file read of a file over 256 KB is refused.&lt;br&gt;
What Claude receives when a read goes over those defaults depends on how it asked:&lt;br&gt;
Situation&lt;br&gt;
What Claude gets&lt;br&gt;
Whole file over the token limit&lt;br&gt;
The first page of the file, with a PARTIAL view notice saying how much arrived and how to read more with offset and limit&lt;br&gt;
Whole file over 256 KB&lt;br&gt;
An error telling it to read a portion with offset and limit, or search with Grep&lt;br&gt;
An offset or limit read over the token limit&lt;br&gt;
The same kind of error, asking for a smaller range or a search&lt;/p&gt;

&lt;p&gt;The PARTIAL view behavior is why a read can look successful while covering only the start of a file. According to a Claude Code docs issue, that change arrived around v2.1.145. Before it, an oversized whole-file read failed outright with a "file content exceeds maximum allowed tokens" error, which you will still see quoted in older tutorials and issue threads.&lt;br&gt;
Surface differences (third-party report, check before relying on it). A March 2026 GitHub issue reported that the Claude Desktop app capped Read at 10,000 tokens while the command-line version allowed 25,000. The official tools reference does not mention a per-surface difference, so treat this as a user report that may have changed.&lt;br&gt;
A common mix-up. The MAX_MCP_OUTPUT_TOKENS variable controls output from MCP servers only. The same GitHub issue reports that setting it does nothing for the built-in Read tool. For Read, the variable to look at is CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS.&lt;br&gt;
How to Use Claude Code allow_large&lt;br&gt;
Because Claude decides when to set the parameter, using it means making your intent clear.&lt;br&gt;
Check your version. Run claude --version. You need v2.1.296 or later. Run claude update if you are behind.&lt;br&gt;
Say you need the whole file. A request like this tells Claude that partial reads will not do:&lt;br&gt;
I need the entire file read in one call, nothing omitted:&lt;br&gt;
/path/to/schema.generated.sql&lt;br&gt;
Summarize every table and flag missing foreign keys.&lt;br&gt;
Check what came back. Look for a PARTIAL view notice or a truncation message. If you see one, Claude did not get the whole file.&lt;br&gt;
Mind the context cost. A whole-file read stays in the session. If you only need one function or one error, do not ask for the whole file.&lt;br&gt;
The Read tool's inputs include an absolute file path, the optional offset and limit, and allow_large. A whole-file read looks roughly like this (an illustration of the documented field names, not something you type):&lt;br&gt;
{&lt;br&gt;
  "file_path": "/home/dev/project/schema.generated.sql",&lt;br&gt;
  "allow_large": true&lt;br&gt;
}&lt;br&gt;
Explicit wording matters in practice. A long GitHub issue titled "Need a way to enforce entire file reading" shows users getting partial reads on files as small as a few hundred lines, with a plain "read the entire file" instruction often fixing it and CLAUDE.md instructions described as unreliable. Some commenters suggested patching the minified CLI. That is unsupported and can break on every update, so do not do it. Ask in the prompt, and on v2.1.296 or later let Claude use allow_large.&lt;br&gt;
Evidence From an Independent Test&lt;br&gt;
Classmethod's developer blog published a hands-on test on Claude Code v2.1.296 using a 3,000-line text file of about 204 KB. Without allow_large, Read returned 732 of 3,001 lines and flagged truncation by the token cap. When the prompt said the entire file was needed, Claude set allow_large to true on its own and received all 3,001 lines in one call. The author reported the same behavior on Opus 5.5 and Haiku 5.5. The extra line is the empty line after the final newline.&lt;br&gt;
Two cautions. This is one author's test, not a guarantee. And the file was under the 256 KB limit, so the token cap was what truncated it. The author also saw the full read cost less than the truncated one in that single-turn test, but that comparison should not be generalized to real sessions where the file then sits in context for every later turn.&lt;br&gt;
Practical Examples for Reading Large Files&lt;br&gt;
A large source file you need to review end to end&lt;br&gt;
Read all of src/generated/api_client.py in one call and list every&lt;br&gt;
public class and its methods.&lt;br&gt;
If you only need one class, ask for that section instead.&lt;br&gt;
A specific section of a long file&lt;br&gt;
Read lines 1200-1400 of src/orders/processor.ts and explain the retry logic.&lt;br&gt;
Here offset is the starting line and limit is how many lines to read. This works even when the whole file would exceed the defaults.&lt;br&gt;
A 400 KB log file&lt;br&gt;
A 400 KB log is over the 256 KB whole-file limit and, by the rough four-characters-per-token estimate, around 100,000 tokens. Even with allow_large you rarely want all of that in context. Search first:&lt;br&gt;
Search app.log for "ERROR" and "timeout" and show the 20 lines around&lt;br&gt;
the first three matches.&lt;br&gt;
On macOS, Linux, and WSL the Grep tool is absent by default and Claude searches with grep and finds through Bash instead. Reading through Bash is not a way around limits: Bash returns about 30,000 characters inline by default, then saves longer output to a file and returns a path plus a short preview.&lt;br&gt;
A large configuration file where every key matters&lt;br&gt;
I need the complete config/production.yaml read in full. Compare it with&lt;br&gt;
config/staging.yaml and list every differing key.&lt;br&gt;
This is a reasonable allow_large case if both files fit comfortably in your remaining context.&lt;br&gt;
A long PDF or a big notebook&lt;br&gt;
allow_large does not change PDF or notebook limits. For PDFs longer than 10 pages, Claude reads in ranges using a pages parameter such as "1-5", up to 20 pages at a time. Page-range reads need pdftoppm from poppler-utils installed. A notebook whose cells exceed 256 KB or the token limit returns an error, and the error explains how to read a slice of cells with a shell command.&lt;br&gt;
allow_large vs. offset and limit vs. Search vs. Subagents&lt;br&gt;
Approach&lt;br&gt;
Best for&lt;br&gt;
Trade-off&lt;br&gt;
allow_large&lt;br&gt;
Tasks that truly need the whole file at once&lt;br&gt;
Uses a lot of context; bounded by the context window&lt;br&gt;
offset and limit&lt;br&gt;
A known region, or paging through a big file&lt;br&gt;
More calls; you need to know where to look&lt;br&gt;
Grep or grep via Bash&lt;br&gt;
Finding errors, symbols, or strings&lt;br&gt;
You see matches, not the surrounding structure&lt;br&gt;
Subagent&lt;br&gt;
Heavy reading you do not want in the main conversation&lt;br&gt;
You get a summary, not the raw content&lt;/p&gt;

&lt;p&gt;A simple rule: if you can name what you are looking for, search. If you know where it is, use offset and limit. If the task needs everything and it fits, use allow_large. If the reading is heavy and you only need conclusions, hand it to a subagent, which has its own context window and returns only its final report.&lt;br&gt;
Keep Your Context Healthy After a Big Read&lt;br&gt;
A whole-file read can use a large share of the window. These built-in controls help:&lt;br&gt;
/context shows how much of the context window is in use, so you can check before and after a big read.&lt;br&gt;
/compact summarizes the conversation, optionally with instructions on what to keep. /clear starts fresh when you switch to unrelated work.&lt;br&gt;
autoCompactWindow sets how full the context gets before automatic compaction. It accepts a number of tokens from 100,000 to 1,000,000, or "auto". Since v2.1.288 the /autocompact command saves this per model. v2.1.296 also lets a subagent set its own autoCompactWindow so it compacts earlier than the main conversation.&lt;br&gt;
Read deny rules in settings.json keep Claude out of paths it should never open. A deny rule such as Read(./secrets/**) blocks reads entirely, and per the permissions docs it also blocks Edit and Write on that path, so use it only for files Claude should not touch.&lt;br&gt;
One third-party guide suggests running /compact when usage reaches about 70 percent. Treat that as a rule of thumb, not an official threshold.&lt;br&gt;
Community Tools for Very Large Files&lt;br&gt;
allow_large helps when the file fits in context. For multi-gigabyte logs or datasets it will not, and some developers use MCP servers that read in chunks and search without loading everything. Examples include Large File MCP, whose author describes tools for chunked reading, regex search, and streaming, and pdf-mcp, which reads large PDFs incrementally by searching first and reading only the relevant pages. These are third-party projects, and their performance claims come from their authors. Review any MCP server before installing it, since it runs with access to your files.&lt;br&gt;
Claude Code Limits vs. Claude Chat Limits&lt;br&gt;
People often mix these up. The Read tool limits above apply inside Claude Code. The claude.ai chat has separate upload limits. A third-party summary of Anthropic's help center, dated October 2026, lists up to 20 files per chat, 500 MB per file, and PDFs up to 1,000 pages. Those figures change, so check Anthropic's help center. If you see a "message exceeds the length limit for this chat" error, that is the chat, not the Read tool, and allow_large will not fix it.&lt;br&gt;
Troubleshooting&lt;br&gt;
Claude only seems to have seen the top of the file. Look for a PARTIAL view notice. Ask Claude to continue with offset and limit, or say plainly that you need the whole file.&lt;br&gt;
"Read a portion" or "search instead" errors. Your read exceeded a default limit. Use offset and limit with a smaller range, or on v2.1.296 or later ask for the whole file.&lt;br&gt;
allow_large does not seem to exist. Run claude --version and update if it is below v2.1.296.&lt;br&gt;
Claude will not use allow_large. It is Claude's decision. State that you need the entire file and accept the context cost. If the file is larger than your remaining context, ranges or search are the right call anyway.&lt;br&gt;
Edits fail after a partial read. A read cut short by a PARTIAL view notice does not count for the read-before-edit rule on older models. Have Claude read the relevant part fully, then edit.&lt;br&gt;
Garbled characters or refused edits. Edit and NotebookEdit refuse files that are not valid UTF-8, such as Shift-JIS or Windows-1252 text. This is separate from file size. The docs recommend a shell command that preserves the encoding, or converting the file to UTF-8 first.&lt;br&gt;
Raising the limit did not help. MAX_MCP_OUTPUT_TOKENS affects MCP output only. Use CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS for the Read tool.&lt;br&gt;
Frequently Asked Questions&lt;br&gt;
What does allow_large do in Claude Code? &lt;br&gt;
It lets the Read tool return a whole text file, or a long line range, in one call beyond the default limits, sized against your remaining context window.&lt;br&gt;
Which version added it? &lt;br&gt;
Claude Code v2.1.296 or later.&lt;br&gt;
Can I turn it on with a flag or setting?&lt;br&gt;
 I found no documented flag or setting. The docs describe Claude setting it when needed, for example when you ask for the entire file.&lt;br&gt;
What are the default Read limits? &lt;br&gt;
25,000 tokens per call by default, adjustable with CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS, and whole-file reads over 256 KB are refused.&lt;br&gt;
Does it work on PDFs, images, or notebooks?&lt;br&gt;
 No. Those keep their own limits.&lt;br&gt;
Is there a maximum file size with allow_large? &lt;br&gt;
The official docs I reviewed do not give one. The practical limit is your context window.&lt;br&gt;
Is it better than offset and limit? &lt;br&gt;
Only when the task needs the whole file at once. For a known region or a specific error, offset, limit, or search costs less context.&lt;br&gt;
Conclusion&lt;br&gt;
allow_large solves a specific problem: Claude needs an entire text file and the default limits get in the way. It is useful, but it is not magic. It needs Claude Code v2.1.296 or later, applies only to text files, and is bound by your context window. For most debugging, offset, limit, and targeted search still cost less. Match the method to the task and you will spend less context and get better answers.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fepif3b9tyeojkfcs6o32.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fepif3b9tyeojkfcs6o32.jpg" alt=" " width="800" height="420"&gt;&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Claude Code Plugin Marketplace: How to Install Plugins</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Thu, 15 Oct 2026 06:22:16 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/claude-code-plugin-marketplace-how-to-install-plugins-272d</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/claude-code-plugin-marketplace-how-to-install-plugins-272d</guid>
      <description>&lt;p&gt;Plugins add skills, agents, hooks, and MCP servers to Claude Code without you building any of them. The Claude Code plugin marketplace is where you find them. The confusing part is that "marketplace" and "plugin" are two different things: a marketplace is a catalog, and each plugin in it is a separate item. Install commands also behave differently inside a session than in your terminal, and they change depending on where the plugin comes from.&lt;br&gt;
This guide shows how to find plugins, install them with the right scope, add a custom marketplace, use the --marketplace option, verify the result, manage plugins afterwards, and fix the errors people hit most.&lt;br&gt;
What Is the Claude Code Plugin Marketplace?&lt;br&gt;
A plugin is a package that extends Claude Code. It can contain skills, agents, hooks, and MCP servers. A marketplace is a catalog that lists plugins and tells Claude Code where to fetch them. Claude Code has to know about a marketplace before you can install anything from it.&lt;br&gt;
You will meet three kinds of marketplace:&lt;br&gt;
The official marketplace, named claude-plugins-official. Anthropic maintains it, and Claude Code registers it automatically the first time you start an interactive terminal session.&lt;br&gt;
Anthropic's community marketplace, which you add yourself. Its registered name is claude-community, even though its repository is called claude-plugins-community.&lt;br&gt;
Custom marketplaces, which anyone can publish in a Git repository, at a URL, or in a local folder.&lt;br&gt;
A marketplace name only tells you who publishes the catalog. It does not tell you what each plugin does, so review plugins from every marketplace before installing.&lt;br&gt;
Before You Install a Claude Code Plugin&lt;br&gt;
Claude Code installed and launched. Follow Anthropic's official setup instructions for your platform, then run claude in your project folder.&lt;br&gt;
Your version number. Some flags depend on the version. Check yours from your terminal:&lt;br&gt;
claude --version&lt;br&gt;
Terminal commands versus session commands. This is the most common source of confusion.&lt;br&gt;
/plugin ... is a slash command you type inside a running Claude Code session. Typed at a normal shell prompt, it fails with an error such as zsh: no such file or directory: /plugin.&lt;br&gt;
claude plugin ... is a shell command you run in your terminal, with no session needed. claude plugins works as an alias.&lt;br&gt;
In non-interactive runs such as claude -p, /plugin is not available, so use the claude plugin shell commands there.&lt;br&gt;
A trust check. A plugin you install can execute code on your machine with your user privileges. Read its details before you confirm (more in the security section).&lt;br&gt;
How to Find Plugins in the Official Marketplace&lt;br&gt;
Start Claude Code with Claude.&lt;br&gt;
Type /plugin. The panel opens on the Discover tab, which lists plugins from all your marketplaces.&lt;br&gt;
Type to search, then press Enter on a plugin to open its details.&lt;br&gt;
The details pane is where you decide whether a plugin fits your workflow. It shows the description and can also show:&lt;br&gt;
Will install: the commands, agents, skills, hooks, and MCP and LSP servers the plugin adds.&lt;br&gt;
Last updated: shown for plugins in the official marketplace.&lt;br&gt;
Context cost: for official-marketplace plugins, estimates of the tokens the plugin adds to every turn and when its skills or agents are invoked. This appears when you open the plugin by naming its marketplace or from the Marketplaces tab, but not from the Discover list.&lt;br&gt;
Plugins from custom marketplaces may show "Components will be discovered at installation" instead, so you cannot always preview their contents.&lt;br&gt;
If Discover is empty, or you see "No marketplaces configured," the official marketplace is not registered yet. Add it with:&lt;br&gt;
/plugin marketplace add anthropics/claude-plugins-official&lt;br&gt;
Other places to look: plugins you turn on in your claude.ai account can sync into Claude Code and appear with the @synced suffix.&lt;br&gt;
How to Install a Claude Code Plugin&lt;br&gt;
The command follows one pattern:&lt;br&gt;
/plugin install @&lt;br&gt;
/plugin install is the session command.&lt;br&gt;
 is the plugin's name in the catalog.&lt;br&gt;
@ says which catalog it comes from. This is the marketplace's registered name, not its repository or URL.&lt;br&gt;
Here is an example from the official marketplace. It installs commit-commands, which adds commands for committing, pushing, and opening pull requests. Run it inside a Claude Code session:&lt;br&gt;
/plugin install commit-commands@claude-plugins-official&lt;br&gt;
In a session this does not install immediately. It opens the plugin's details so you can review it and choose a scope. After you pick one, Claude Code installs the plugin and any dependencies it declares, then prints a summary.&lt;br&gt;
Choosing an Installation Scope&lt;br&gt;
Scope&lt;br&gt;
Menu option&lt;br&gt;
Who gets it&lt;br&gt;
Recorded in&lt;br&gt;
User&lt;br&gt;
Install for you&lt;br&gt;
You, in every project on this machine&lt;br&gt;
~/.claude/settings.json&lt;br&gt;
Project&lt;br&gt;
Install for all collaborators on this repository&lt;br&gt;
Everyone who works in this repository&lt;br&gt;
.claude/settings.json (you commit it)&lt;br&gt;
Local&lt;br&gt;
Install for you, in this repo only&lt;br&gt;
You, in this repository only&lt;br&gt;
.claude/settings.local.json&lt;/p&gt;

&lt;p&gt;If the same plugin is set at several scopes, local overrides project, and project overrides user.&lt;br&gt;
Project scope has a catch. Committing the settings entry enables the plugin for collaborators but does not download it to their machines. Each collaborator runs this once:&lt;br&gt;
claude plugin install @ --scope project&lt;br&gt;
Installing from Your Terminal Instead&lt;br&gt;
claude plugin install commit-commands@claude-plugins-official --scope project&lt;br&gt;
Without --scope, the shell command installs at user scope. Valid values are user, project, and local. On success it prints Successfully installed plugin: commit-commands@claude-plugins-official (scope: project).&lt;br&gt;
One caveat: on a machine where nobody has opened an interactive session yet, the official marketplace is not registered, because shell commands never register it. Run claude plugin marketplace add anthropics/claude-plugins-official first.&lt;br&gt;
How to Install a Plugin from a Custom Marketplace&lt;br&gt;
Many plugins are not in the official marketplace. A coworker's plugin or an open-source project's plugin lives in its own catalog. Claude Code has no global index to look marketplace names up in, so an install line like name@some-marketplace will not work until you have added that marketplace.&lt;br&gt;
The values below are placeholders (your-org/plugins, deploy-helper). They do not refer to a real marketplace or plugin, so replace them with your own.&lt;br&gt;
Add the marketplace (in a session):&lt;br&gt;
/plugin marketplace add your-org/pluginsThe source can be a GitHub owner/repo (add #ref to pin a branch or tag), a full git URL, a local path starting with ./ or ../, or an https:// link to a hosted marketplace.json. Include the https:// prefix on URLs: a bare gitlab.example.com/group/repo is read as GitHub shorthand and fails.&lt;br&gt;
Identify the marketplace name. The success message reads Successfully added marketplace: . That name comes from the marketplace's own manifest and may differ from the repository name. You can also list names:&lt;br&gt;
/plugin marketplace list&lt;br&gt;
Install the plugin using that registered name:&lt;br&gt;
/plugin install deploy-helper@&lt;br&gt;
Confirm the scope in the details pane.&lt;br&gt;
Verify that the plugin is available (see the verification section).&lt;br&gt;
The new marketplace appears on the Discover tab the next time you open /plugin, with no reload needed. Auto-update is off by default for community and third-party marketplaces, so refresh them yourself with /plugin marketplace update .&lt;br&gt;
How to Use the Claude Code --marketplace Option&lt;br&gt;
The --marketplace option combines two steps: it registers a marketplace you have not added yet and starts the plugin install. You pass the marketplace source, and you give the plugin name by itself, with no &lt;a class="mentioned-user" href="https://dev.to/marketplace"&gt;@marketplace&lt;/a&gt; suffix.&lt;br&gt;
In a session (requires Claude Code v2.1.275 or later):&lt;br&gt;
/plugin install deploy-helper --marketplace your-org/plugins&lt;br&gt;
Claude Code shows the source it resolved and asks you to confirm before adding the marketplace. Then the plugin's details open and you choose a scope. If the source matches a marketplace you have already added, it skips the confirmation. In a session, the source cannot contain spaces.&lt;br&gt;
From your shell (requires Claude Code v2.1.292 or later):&lt;br&gt;
claude plugin install deploy-helper --marketplace your-org/plugins&lt;br&gt;
The shell version adds the marketplace without a confirmation step, so be sure of the source before you run it. A new marketplace added this way is declared in your user settings even if you pass --scope project. A marketplace you already added from the same source is reused.&lt;br&gt;
The two forms have different minimum versions, so do not assume one number covers both. Run claude plugin install --help to confirm your build supports the flag.&lt;br&gt;
Source versus name. In --marketplace your-org/plugins, the value is a source: where to fetch the catalog. In deploy-helper@marketplace-name, the part after the @ is the registered name: what the catalog calls itself. They often differ.&lt;br&gt;
Two limitations to know about:&lt;br&gt;
/plugin install your-org/plugins (a source with no plugin name and no --marketplace) installs nothing and reports a "marketplace not found" error.&lt;br&gt;
If the catalog at your source has the same name as a marketplace you already added from a different source, Claude Code keeps the existing one and installs nothing. Remove the old marketplace first if you want the new source.&lt;br&gt;
Claude Code Plugin Installation Examples&lt;br&gt;
Replace the placeholders in angle brackets with your own values.&lt;br&gt;
Goal&lt;br&gt;
Command&lt;br&gt;
Where to run it&lt;br&gt;
Browse plugins&lt;br&gt;
/plugin&lt;br&gt;
Claude Code session&lt;br&gt;
Install from a registered marketplace&lt;br&gt;
/plugin install @&lt;br&gt;
Claude Code session&lt;br&gt;
Install at project scope from the terminal&lt;br&gt;
claude plugin install @ --scope project&lt;br&gt;
System shell&lt;br&gt;
Add a marketplace&lt;br&gt;
/plugin marketplace add &lt;br&gt;
Claude Code session&lt;br&gt;
Add a marketplace from the terminal&lt;br&gt;
claude plugin marketplace add &lt;br&gt;
System shell&lt;br&gt;
Add a marketplace and install in one step&lt;br&gt;
/plugin install  --marketplace  (v2.1.275+)&lt;br&gt;
Claude Code session&lt;br&gt;
Same, from the terminal&lt;br&gt;
claude plugin install  --marketplace  (v2.1.292+)&lt;br&gt;
System shell&lt;br&gt;
List registered marketplaces&lt;br&gt;
/plugin marketplace list&lt;br&gt;
Claude Code session&lt;br&gt;
Refresh a marketplace listing&lt;br&gt;
/plugin marketplace update &lt;br&gt;
Claude Code session&lt;br&gt;
List installed plugins&lt;br&gt;
/plugin list (v2.1.163+)&lt;br&gt;
Claude Code session&lt;br&gt;
List installed plugins with status&lt;br&gt;
claude plugin list&lt;br&gt;
System shell&lt;br&gt;
Apply pending plugin changes&lt;br&gt;
/reload-plugins&lt;br&gt;
Claude Code session&lt;/p&gt;

&lt;p&gt;How to Verify That a Plugin Is Installed&lt;br&gt;
Start with the install summary. Its last sentence tells you the plugin's state:&lt;br&gt;
"Plugin is now active." No reload is needed.&lt;br&gt;
"Run /reload-plugins to apply." Claude Code runs the reload for you when the panel closes. If the reload would invalidate the prompt cache, it warns and leaves the plugin pending. Run /reload-plugins --force to activate it anyway, which costs one uncached request.&lt;br&gt;
"The plugin couldn't be loaded." Open the Errors tab in /plugin for the reason.&lt;br&gt;
Active, but a bundled MCP server needs configuration. Open the plugin on the Installed tab and choose Configure.&lt;br&gt;
So not every plugin needs a reload. The summary tells you. Plugins installed from your shell load the next time you start Claude Code, or when you run /reload-plugins in an open session.&lt;br&gt;
Then confirm the plugin in any of these ways:&lt;br&gt;
Type / and look for the plugin's skills in the form /:. For commit-commands, that is /commit-commands:commit. The namespace prevents two plugins from colliding on similar command names.&lt;br&gt;
Open the Installed tab in /plugin, which lists each plugin with its scope.&lt;br&gt;
Run claude plugin list in your shell. It prints Version, Scope, and Status for each plugin.&lt;br&gt;
How to Manage Plugins After Installing&lt;br&gt;
Disable or enable: On the Installed tab, press Space on a plugin. From your shell, use claude plugin disable @ or claude plugin enable @.&lt;br&gt;
Uninstall: Use /plugin uninstall  in a session, or claude plugin uninstall @ --scope project in your shell. If the project's shared settings enable the plugin, Claude Code asks whether to disable it only for you or uninstall it for everyone.&lt;br&gt;
Update: Run claude plugin update @. No single command updates every plugin. To update everything from one marketplace, open the Marketplaces tab in /plugin, select it, and choose Update marketplace. A running session keeps the versions it already loaded, so run /reload-plugins or start a new session.&lt;br&gt;
Remove a marketplace: This also uninstalls every plugin you installed from it. To refresh a marketplace without losing its plugins, use update instead of remove.&lt;br&gt;
Check the cost: Run claude plugin details  in your shell. The Always-on line shows how many tokens the plugin adds to every session.&lt;br&gt;
Common Claude Code Plugin Marketplace Errors and Fixes&lt;br&gt;
These come from Anthropic's troubleshooting guidance. Exact messages vary by version, so treat the fixes as starting points rather than guarantees.&lt;br&gt;
Problem: Marketplace "claude-plugins-official" not found, or the same message for another marketplace name.&lt;br&gt;
Likely cause: The marketplace is not registered on this machine. For the official one, that happens if you have only used the VS Code extension, or if a policy or environment setting blocks auto-registration. For other names, the install line you received does not say where the marketplace is hosted.&lt;br&gt;
Fix: Run /plugin marketplace add anthropics/claude-plugins-official for the official marketplace. For any other, ask whoever sent the line for the marketplace's source, add it with /plugin marketplace add , and rerun the install. If you already added it, compare the spelling against /plugin marketplace list.&lt;br&gt;
Problem: Plugin "" not found in marketplace "".&lt;br&gt;
Likely cause: A misspelled plugin name, or a local copy of the catalog that is out of date.&lt;br&gt;
Fix: Copy the name from the Discover tab. If the message includes a refresh hint, run /plugin marketplace update  and install again.&lt;br&gt;
Problem: Invalid marketplace source format.&lt;br&gt;
Likely cause: The source is not in an accepted form. A bare name such as claude-plugins-official or a bare hostname does not qualify.&lt;br&gt;
Fix: Use owner/repo, a full https:// URL, user@host:path, or a path beginning with ./, ../, /, or ~.&lt;br&gt;
Problem: SSH authentication failed or HTTPS authentication failed when adding or updating a marketplace.&lt;br&gt;
Likely cause: Claude Code runs git with interactive prompts disabled, so only credentials that already work non-interactively succeed. A misspelled repository or one you cannot see can produce the same message.&lt;br&gt;
Fix: Run git ls-remote  in your terminal to confirm the repository exists and you have access. For SSH, ssh -T git@ must succeed without a passphrase prompt. For GitHub over HTTPS, run gh auth login and gh auth setup-git. Retry once git ls-remote works without prompting.&lt;br&gt;
Problem: The plugin appears installed but does not work.&lt;br&gt;
Likely cause: It may need a reload, may have load errors, may be disabled, or may not contain what you expected.&lt;br&gt;
Fix: Open /plugin, check Installed for enabled status, and read the Errors tab. Run /reload-plugins if you installed during this session. Check the plugin's details pane to see what it actually adds.&lt;br&gt;
Problem: A code intelligence (language server) plugin is installed, but the Errors tab shows Executable not found in $PATH.&lt;br&gt;
Likely cause: These plugins connect to a language server binary that you install separately. The plugin alone is not enough.&lt;br&gt;
Fix: Install the language server binary, confirm it is on the PATH of the terminal you start claude from (for example with which typescript-language-server), then start a new session.&lt;br&gt;
Problem: error: unknown command 'add', unknown option '--project', or Unknown command: /install.&lt;br&gt;
Likely cause: Those spellings do not exist. Some older tutorials still use them.&lt;br&gt;
Fix: Use claude plugin marketplace add  to add a marketplace, claude plugin install @ to install, --scope project instead of --project, and /plugin install ... instead of /install. A rejected --marketplace flag usually means your Claude Code version is older than the minimum above, so update Claude Code.&lt;br&gt;
Problem: A plugin is "enabled in project settings but isn't installed here," or you are unsure which scope applies.&lt;br&gt;
Likely cause: A repository's settings can enable a plugin for everyone, but they do not download it. Separately, when a plugin is set at several scopes, the most specific one wins.&lt;br&gt;
Fix: Run claude plugin install @ --scope project, then /reload-plugins. Run claude plugin list to see each plugin's scope.&lt;br&gt;
Plugin Security and Best Practices&lt;br&gt;
Anthropic's documentation states that an installed plugin can execute arbitrary code on your machine with your user privileges. That is a reason for a quick review habit, not for alarm.&lt;br&gt;
Check source and maintainer. A marketplace name tells you who publishes the catalog, not what every plugin in it does. Prefer plugins from maintainers you recognize.&lt;br&gt;
Read "Will install" before you confirm. Hooks and MCP servers deserve the closest look. Hooks run commands in response to events, and MCP servers give Claude access to external tools and data. Their processes are separate from Claude's own tool calls, so a plugin's description is not a substitute for reading its hook and MCP configuration.&lt;br&gt;
Be careful with unfamiliar repositories. This applies to --marketplace especially, because the shell form adds the marketplace without asking.&lt;br&gt;
Remember that updates can change what you reviewed. When auto-update is on for a marketplace, Claude Code updates its plugins in the background. It is on by default for the official marketplace and off by default for third-party ones. For a third-party plugin you audited carefully, leave auto-update off and update by hand.&lt;br&gt;
Agree on project-level plugins as a team. Project scope puts the plugin in a committed settings file, so everyone gets the same setup. Decide together what goes there, and keep personal experiments at user or local scope.&lt;br&gt;
To remove a plugin you no longer trust, uninstall it. If you do not trust the marketplace either, remove the marketplace too.&lt;br&gt;
Frequently Asked Questions&lt;br&gt;
What is the Claude Code plugin marketplace?&lt;br&gt;
A catalog of plugins that Claude Code can install from. The official one is claude-plugins-official, and you can add others from Git repositories, URLs, or local paths.&lt;br&gt;
How do I install a Claude Code plugin?&lt;br&gt;
Run /plugin install @ in a session, choose a scope, and read the install summary. From your shell, use claude plugin install @.&lt;br&gt;
How do I install a plugin from a custom marketplace?&lt;br&gt;
Add the marketplace with /plugin marketplace add , then install with the registered marketplace name. Or use --marketplace to do both at once.&lt;br&gt;
What does the Claude Code --marketplace option do?&lt;br&gt;
It registers a marketplace you have not added and starts the plugin install in one command. It requires v2.1.275 or later in a session and v2.1.292 or later from the shell.&lt;br&gt;
Do I need to add the official marketplace manually?&lt;br&gt;
Usually not. Claude Code registers it on your first interactive terminal session. You may need to add it yourself if you have only used the VS Code extension, if a policy blocks auto-registration, or on a fresh machine where you install from the shell.&lt;br&gt;
How do I list installed Claude Code plugins?&lt;br&gt;
Use /plugin list in a session (v2.1.163 or later), open the Installed tab in /plugin, or run claude plugin list in your shell.&lt;br&gt;
Why is my plugin not appearing after installation?&lt;br&gt;
Check the Installed and Errors tabs in /plugin, and run /reload-plugins if you installed during this session. Open the plugin's details to confirm what it provides.&lt;br&gt;
Can I share a plugin installation with my team?&lt;br&gt;
Yes, with project scope. It records the plugin in .claude/settings.json, which you commit. Collaborators still run claude plugin install @ --scope project once to download it.&lt;br&gt;
How do I update Claude Code plugins?&lt;br&gt;
Run claude plugin update @, or use Update marketplace on the Marketplaces tab. No single command updates every plugin.&lt;br&gt;
How do I uninstall a plugin?&lt;br&gt;
Use /plugin uninstall  in a session, or claude plugin uninstall @ in your shell. Add --scope to target one scope.&lt;br&gt;
Conclusion&lt;br&gt;
The simplest workflow is short. Open Claude Code, run /plugin to browse the Claude Code plugin marketplace, review the plugin's details, and install it with /plugin install @. If the plugin lives in another marketplace, add that marketplace first, or use --marketplace to combine both steps. Before you confirm any install, check who published the plugin and choose the scope that matches who should have it.&lt;br&gt;
Want more practical Claude Code walkthroughs? Keep exploring the guides on HustleToAI.&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>programming</category>
      <category>cloudskills</category>
      <category>devchallenge</category>
    </item>
    <item>
      <title>Claude Code Read Large Files: Limits &amp; allow_large</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Wed, 14 Oct 2026 09:40:03 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/claude-code-read-large-files-limits-allowlarge-14l8</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/claude-code-read-large-files-limits-allowlarge-14l8</guid>
      <description>&lt;p&gt;Claude Code Dynamic Workflows: Practical Guide&lt;/p&gt;

&lt;p&gt;Most AI coding sessions follow one pattern: you ask, the assistant works, you review, you ask again. That pattern is fine for a bug fix. It breaks down on a migration that touches hundreds of files or an audit of an entire service. The context window fills up, the original instructions get compressed away, and you end up acting as the project manager.&lt;/p&gt;

&lt;p&gt;Claude Code dynamic workflows are Anthropic's answer to that problem. This guide explains what they are, how they work, how they differ from subagents, skills, hooks and agent teams, and how to use them on large coding tasks without wasting usage. Every feature, command and limit below was checked against Anthropic's official documentation and announcement. Claims from community articles are labeled as community sources.&lt;/p&gt;

&lt;p&gt;Dune: Part Three: Full HD&lt;br&gt;
We have 117 new singles for you&lt;br&gt;
Hey Honey! Wanna Date?&lt;br&gt;
Find a girl! 100% Free website!&lt;br&gt;
Why static coding workflows struggle with complex tasks&lt;br&gt;
A single chat session is one fixed loop: Claude reads, decides, acts, and keeps every intermediate result in one context window. Community analyses of Claude Code workflows describe three recurring failure modes when that single window carries a big job:&lt;/p&gt;

&lt;p&gt;Agentic laziness. On a long, multi-part task, Claude reviews part of the list and then reports that the job is done. A security review that covers 35 of 50 files is the usual example.&lt;/p&gt;

&lt;p&gt;Self-preferential bias. When Claude grades its own output inside the same conversation, it tends to rate it generously.&lt;/p&gt;

&lt;p&gt;Goal drift. Over many turns, and especially after context compaction, details such as "do not touch the auth module" can fade.&lt;/p&gt;

&lt;p&gt;Anthropic's own best-practices guide points at the same root cause: the context window fills quickly, and performance degrades as it fills. Dynamic workflows attack the problem structurally, by moving the plan out of the conversation and into a script.&lt;/p&gt;

&lt;p&gt;What are Claude Code dynamic workflows?&lt;br&gt;
Dynamic workflows are an official, named Claude Code feature, not just a design idea. According to the official documentation, a dynamic workflow is a JavaScript script that orchestrates many subagents at once. Claude writes the script for the task you describe, and a runtime executes it in the background while your session stays responsive.&lt;/p&gt;

&lt;p&gt;Key facts, all from Anthropic's announcement and docs:&lt;/p&gt;

&lt;p&gt;Announced May 28, 2026. The announcement now carries an update saying dynamic workflows are generally available, so older articles that call them a research preview are out of date.&lt;/p&gt;

&lt;p&gt;Available in the Claude Code CLI, Desktop app and VS Code extension, and on the Claude API, Amazon Bedrock, Vertex AI and Microsoft Foundry. The docs say they are available on all paid plans. They are on by default for Max, Team and Enterprise, and Pro users turn them on from the Dynamic workflows row in /config.&lt;/p&gt;

&lt;p&gt;Anthropic says they consume meaningfully more usage than a typical session, so it recommends starting with a scoped task. The first time a workflow triggers, Claude Code shows what is about to run and asks you to confirm. Organization admins can disable workflows through managed settings.&lt;/p&gt;

&lt;p&gt;Community sources report that the feature arrived in v2.1.154 and that the original trigger keyword workflow was renamed ultracode in v2.1.160. Check claude --version and the changelog if you are on an older build.&lt;/p&gt;

&lt;p&gt;The word "dynamic" has two meanings here. Claude writes the orchestration fresh for each task, instead of you wiring a fixed pipeline. And the script itself can adapt at runtime: it can branch on results, retry, or loop until a condition is met.&lt;/p&gt;

&lt;p&gt;How Claude Code dynamic workflows work&lt;br&gt;
The central idea is who holds the plan. In a normal session, Claude is the orchestrator and decides turn by turn what to do next, and every result lands in its context window. In a workflow, the script holds the loop, the branching and the intermediate results in variables, so Claude's context holds only the final answer.&lt;/p&gt;

&lt;p&gt;The lifecycle of a run:&lt;/p&gt;

&lt;p&gt;Trigger. You ask for a workflow in plain words, include the keyword ultracode in your prompt, or turn on ultracode for the session.&lt;/p&gt;

&lt;p&gt;Script generation. Claude writes a JavaScript orchestration script for the task.&lt;/p&gt;

&lt;p&gt;Approval. Claude Code shows the planned phases. You can read the raw script before approving.&lt;/p&gt;

&lt;p&gt;Background execution. Agents run while you keep working. Run /workflows to watch progress.&lt;/p&gt;

&lt;p&gt;Verification and iteration. Depending on how the script is written, agents cross-check each other, retry, or loop.&lt;/p&gt;

&lt;p&gt;Report. You receive one consolidated result.&lt;/p&gt;

&lt;p&gt;Three practical consequences follow. First, every run writes its script to a file under ~/.claude/projects/, so you can read, diff or edit the orchestration. Second, progress is saved as the run goes, so an interrupted run can pick up where it stopped. Third, community sources point out that the script itself costs no model tokens, since it is ordinary code; all token cost comes from the agents it spawns. A product manager who measured a run on 100 synthetic interview transcripts reported 113 agents, about 1.95 million tokens and 12.5 minutes. Treat that as one data point from a non-coding task, not a benchmark.&lt;/p&gt;

&lt;p&gt;Core Claude Code features that enable adaptive workflows&lt;br&gt;
Dynamic workflows sit alongside several other features. They are not interchangeable. The official documentation compares subagents, skills, agent teams and workflows by who decides what runs next:&lt;/p&gt;

&lt;p&gt;Feature&lt;/p&gt;

&lt;p&gt;What it is&lt;/p&gt;

&lt;p&gt;Who decides what runs next&lt;/p&gt;

&lt;p&gt;Scale&lt;/p&gt;

&lt;p&gt;CLAUDE.md&lt;/p&gt;

&lt;p&gt;Persistent project instructions read every session&lt;/p&gt;

&lt;p&gt;Not applicable (context, not control flow)&lt;/p&gt;

&lt;p&gt;Not applicable&lt;/p&gt;

&lt;p&gt;Skills&lt;/p&gt;

&lt;p&gt;Instructions Claude follows, loaded when relevant&lt;/p&gt;

&lt;p&gt;Claude, following the prompt&lt;/p&gt;

&lt;p&gt;Same as subagents&lt;/p&gt;

&lt;p&gt;Hooks&lt;/p&gt;

&lt;p&gt;Shell commands that fire at lifecycle events&lt;/p&gt;

&lt;p&gt;The event, deterministically&lt;/p&gt;

&lt;p&gt;Per tool call&lt;/p&gt;

&lt;p&gt;Subagents&lt;/p&gt;

&lt;p&gt;A worker Claude spawns&lt;/p&gt;

&lt;p&gt;Claude, turn by turn&lt;/p&gt;

&lt;p&gt;A few delegated tasks per turn&lt;/p&gt;

&lt;p&gt;Agent teams (experimental)&lt;/p&gt;

&lt;p&gt;A lead agent supervising peer sessions&lt;/p&gt;

&lt;p&gt;The lead agent, turn by turn&lt;/p&gt;

&lt;p&gt;A handful of long-running peers&lt;/p&gt;

&lt;p&gt;Dynamic workflows&lt;/p&gt;

&lt;p&gt;A script the runtime executes&lt;/p&gt;

&lt;p&gt;The script&lt;/p&gt;

&lt;p&gt;Dozens to hundreds of agents per run&lt;/p&gt;

&lt;p&gt;The CLAUDE.md and hooks rows are my summary; the other rows follow the official comparison table.&lt;/p&gt;

&lt;p&gt;CLAUDE.md and project instructions&lt;br&gt;
CLAUDE.md is read at the start of every conversation and holds build commands, code style and workflow rules. Anthropic advises keeping it short: for each line, ask whether removing it would cause mistakes, and cut it if not. A bloated file makes Claude ignore half of it. Knowledge that only matters sometimes belongs in a skill, which loads on demand. Run /init to generate a starter file.&lt;/p&gt;

&lt;p&gt;Skills and reusable workflows&lt;br&gt;
A skill is a folder with a SKILL.md file. The frontmatter tells Claude when to use it, and the body holds the instructions. Skills live in .claude/skills//SKILL.md for a project or ~/.claude/skills/ for personal use. Setting disable-model-invocation: true keeps Claude from triggering a skill on its own, which suits anything with side effects. A skill is prompt-driven, so it does not guarantee ordering, retries or resume. A community guide suggests a simple boundary: keep interpretation and trade-off judgment in prompts and skills, and put required ordering, retries and stop rules in code.&lt;/p&gt;

&lt;p&gt;Hooks and automated actions&lt;br&gt;
Hooks are deterministic. A CLAUDE.md rule is advice, while a hook makes an action happen every time. They are configured in settings.json files at user, project or local level. Exit code 2 from a hook signals a blocking error. A PreToolUse hook can actually stop an action. A PostToolUse hook runs after the action, so it can only report back to Claude. A Stop hook can run your check script and keep the turn from ending until it passes.&lt;/p&gt;

&lt;p&gt;Subagents and specialized tasks&lt;br&gt;
Subagents are Markdown files with YAML frontmatter in .claude/agents/ or ~/.claude/agents/. Each runs in its own context with its own tool allowlist. They are the workers that a dynamic workflow orchestrates. Claude Code also ships built-in ones such as Explore, Plan and general-purpose.&lt;/p&gt;

&lt;p&gt;Agent teams and parallel sessions&lt;br&gt;
Agent teams are a separate mechanism and are still experimental. They are disabled by default, are enabled with the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS setting, and have known limitations around session resumption, task coordination and shutdown. Each teammate is a full Claude Code session, and teammates coordinate through a shared task list. Use them when peers need to share findings and challenge each other. A workflow agent, by contrast, only executes the step the script hands it. One customer quote in Anthropic's announcement describes workflows as filling the gap between firing off one subagent and building a full agent team.&lt;/p&gt;

&lt;p&gt;Plan mode, /goal and task decomposition&lt;br&gt;
Anthropic recommends exploring, then planning, then coding. Press Shift+Tab until plan mode is on, or start with claude --permission-mode plan. Claude reads and answers without changing files, and you can edit the plan with Ctrl+G. Anthropic's rule of thumb: if you could describe the diff in one sentence, skip the plan. Plan mode is not the same as a workflow's planning stage, which is Claude writing a script. For unattended work, /goal sets a completion condition that a separate evaluator re-checks after every turn.&lt;/p&gt;

&lt;p&gt;Claude Code dynamic workflow architecture, step by step&lt;/p&gt;

&lt;p&gt;Think of three layers:&lt;/p&gt;

&lt;p&gt;Instruction layer: CLAUDE.md and skills describe how your project works.&lt;/p&gt;

&lt;p&gt;Guardrail layer: hooks, permission rules and sandboxing enforce what must always or never happen.&lt;/p&gt;

&lt;p&gt;Orchestration layer: subagents, a workflow script or an agent team decide who does what.&lt;/p&gt;

&lt;p&gt;A typical adaptive run follows Understand, Plan, Implement, Test, Review, Fix, Verify. The path is not fixed. A failing test sends the run back to Fix. A missing dependency sends it back to Plan. In a workflow script, that branching is real code, such as a loop with an exit condition, instead of a hope that Claude remembers to retry.&lt;/p&gt;

&lt;p&gt;Inside the script, the documented building blocks are small:&lt;/p&gt;

&lt;p&gt;agent() spawns one subagent. With a schema option it returns validated JSON, and Claude Code retries until the output matches (up to five attempts by default).&lt;/p&gt;

&lt;p&gt;pipeline() runs one agent per item in a list, streaming items through stages.&lt;/p&gt;

&lt;p&gt;parallel() runs a set of tasks at once and waits for all of them.&lt;/p&gt;

&lt;p&gt;phase() groups agents under a title in the progress view, log() prints a message, and args carries input to a saved workflow.&lt;/p&gt;

&lt;p&gt;A failed or stopped agent() returns null inside pipeline() or parallel(), so scripts filter those out.&lt;/p&gt;

&lt;p&gt;Six patterns worth knowing&lt;br&gt;
Community guides name six recurring shapes. Learning the names helps you ask for the right structure in a prompt:&lt;/p&gt;

&lt;p&gt;Classify-and-act: one agent decides what kind of task it is, and the script routes accordingly. Good for triage.&lt;/p&gt;

&lt;p&gt;Fan-out-and-synthesize: one agent per piece, then one agent merges the results. Good for codebase audits.&lt;/p&gt;

&lt;p&gt;Adversarial verification: a separate agent tries to refute each finding, so the producer never grades its own work.&lt;/p&gt;

&lt;p&gt;Generate-and-filter: produce many candidates, then filter and deduplicate to the survivors.&lt;/p&gt;

&lt;p&gt;Tournament: several agents attempt the same task differently, and a judge compares them pairwise. Pairwise comparison is more reliable than asking an agent to score its own result.&lt;/p&gt;

&lt;p&gt;Loop-until-done: keep going until a stop condition is met, such as two rounds with no new findings.&lt;/p&gt;

&lt;p&gt;Anthropic's announcement describes the same ideas: agents attack the problem from independent angles, other agents try to refute what they found, and the run iterates until answers converge.&lt;/p&gt;

&lt;p&gt;Practical example 1: debugging an unknown error&lt;br&gt;
Problem. A production stack trace points somewhere that makes no sense.&lt;/p&gt;

&lt;p&gt;Honest note. Most debugging does not need a workflow. Start in a normal session and escalate only when the search space is wide.&lt;/p&gt;

&lt;p&gt;Initial prompt. "Here is the stack trace. Do not change code yet. Find the root cause and list your evidence."&lt;/p&gt;

&lt;p&gt;Breakdown. A subagent searches the codebase in its own context so your main window stays clean. Claude forms hypotheses, reproduces the failure with a narrow test, and edits only after the cause is confirmed. This run is sequential and adaptive.&lt;/p&gt;

&lt;p&gt;Features used. Plan mode or an Explore-style subagent, and a failing test written before the fix, as Anthropic's best-practices guide recommends.&lt;/p&gt;

&lt;p&gt;Verify. The reproduction fails before the fix and passes after, and the wider suite stays green.&lt;/p&gt;

&lt;p&gt;If it fails. Discard the hypothesis, tell Claude it was wrong, and ask for the next one. If you have corrected Claude twice on the same issue, Anthropic suggests running /clear and starting over with a better prompt. If the cause could be anywhere in a service, escalate:&lt;/p&gt;

&lt;p&gt;use a workflow to hunt for the cause of this error across src/services/,&lt;br&gt;
one agent per module, with hypotheses from different evidence (logs, source,&lt;br&gt;
data), and adversarially verify each suspected cause before reporting it&lt;br&gt;
Practical example 2: implementing a feature across multiple files&lt;br&gt;
Problem. Add per-user rate limiting touching middleware, config, tests and docs.&lt;/p&gt;

&lt;p&gt;Initial prompt. "Plan first. List the files you will touch and the order. Wait for my approval."&lt;/p&gt;

&lt;p&gt;Features used. Plan mode for the proposal, CLAUDE.md for conventions, and a formatting hook so style never costs a review round. For a larger feature, Anthropic suggests letting Claude interview you with the AskUserQuestion tool and write a spec file, then executing the spec in a fresh session.&lt;/p&gt;

&lt;p&gt;Sequence. Plan, your approval, middleware, config, tests, docs, then the full test run. This is sequential with one human checkpoint.&lt;/p&gt;

&lt;p&gt;Verify. Run the new tests and the existing suite, then read the diff yourself.&lt;/p&gt;

&lt;p&gt;If it fails. Reject the plan before any code is written, which is cheap. A workflow is the wrong tool here because each step depends on the last.&lt;/p&gt;

&lt;p&gt;Practical example 3: running tests and reviewing changes&lt;/p&gt;

&lt;p&gt;Problem. The type check fails with dozens of errors after a dependency upgrade.&lt;/p&gt;

&lt;p&gt;This is a natural workflow case because it is a loop. The official docs give this prompt shape:&lt;/p&gt;

&lt;p&gt;use a workflow to run npx tsc --noEmit and keep fixing the reported errors&lt;/p&gt;

&lt;p&gt;until the type check passes or two rounds in a row make no progress&lt;/p&gt;

&lt;p&gt;The "two rounds with no progress" clause is a stop condition that prevents an endless fix loop. For review, a second workflow can run a reviewer per file and pass all findings to one agent that ranks and deduplicates them.&lt;/p&gt;

&lt;p&gt;Verify. Run the type check and the test suite yourself afterwards. Anthropic stresses give Claude a check it can run, such as tests, a build exit code or a linter, because without one "looks done" is the only signal.&lt;/p&gt;

&lt;p&gt;Review caveat. A reviewer told to find gaps will usually report some, even on sound work. Anthropic advises telling the reviewer to flag only gaps that affect correctness or stated requirements, otherwise you invite over-engineering. The bundled /code-review skill reviews the current diff in a fresh subagent.&lt;/p&gt;

&lt;p&gt;If it fails. Open /workflows to see which agents stalled or failed, then ask Claude to relaunch. Completed agents return their saved results.&lt;/p&gt;

&lt;p&gt;Practical example 4: a large task with multiple agents&lt;br&gt;
Problem. Convert 300 JavaScript components to TypeScript.&lt;/p&gt;

&lt;p&gt;use a workflow to migrate every component under src/components/ from&lt;/p&gt;

&lt;p&gt;JavaScript to TypeScript, working on each file in its own isolated copy,&lt;br&gt;
then review each result and run the type check&lt;br&gt;
Breakdown. Discover the files, migrate each in parallel, run an independent review of each, then run a fix loop against the build and tests.&lt;/p&gt;

&lt;p&gt;This mirrors a large real use. Anthropic reports that Jarred Sumner used workflows to port Bun from Zig to Rust, reaching 99.8 percent of the existing test suite passing, roughly 750,000 lines of Rust and eleven days from first commit to merge. One workflow mapped lifetimes, another ported each file with two reviewers per file, and a fix loop drove the build and tests until they ran clean. Anthropic notes that the result was not yet in production. Treat it as an upper bound, not a typical outcome.&lt;/p&gt;

&lt;p&gt;If it fails. Shrink the scope. The docs recommend running a workflow on a small slice first, such as one directory, to gauge cost. Anthropic's announcement also suggests turning on auto mode for workflows so a long run does not stop on every permission prompt.&lt;/p&gt;

&lt;p&gt;How to build your first dynamic workflow&lt;br&gt;
Update Claude Code and confirm workflows are on (Pro users enable them in /config).&lt;/p&gt;

&lt;p&gt;Try the built-in workflow. Run /deep-research with a question. It fans out searches, cross-checks sources, votes on claims and returns a cited report. It needs the WebSearch tool.&lt;/p&gt;

&lt;p&gt;Watch it. Run /workflows. Press Enter to drill into phases and agents, p to pause or resume, x to stop, r to restart an agent and s to save the script.&lt;/p&gt;

&lt;p&gt;Ask for your own. Say "use a workflow to..." or include ultracode in the prompt.&lt;/p&gt;

&lt;p&gt;Read the script before approving, using "View raw script" or Ctrl+G.&lt;/p&gt;

&lt;p&gt;Save what worked. Saved workflows become slash commands. Project workflows live in .claude/workflows/ (shared with the repo) and personal ones in ~/.claude/workflows/. A project workflow wins a name clash. Plugins can ship workflows too, namespaced by plugin name.&lt;/p&gt;

&lt;p&gt;Ultracode, explained&lt;br&gt;
The keyword and the session setting differ. The keyword ultracode in a prompt opts in a single task. The setting /effort ultracode makes Claude plan a workflow for every substantive task in the session, so each request costs more tokens and takes longer. Launching with claude --effort ultracode also sets effort to xhigh and needs v2.1.203 or later. Turn it off with /effort ultracode off for routine work. While ultracode is on, the Large workflow warning and the first-launch approval in auto mode are skipped.&lt;/p&gt;

&lt;p&gt;Approval prompts by permission mode&lt;br&gt;
Mode&lt;/p&gt;

&lt;p&gt;When you are prompted&lt;/p&gt;

&lt;p&gt;Auto&lt;/p&gt;

&lt;p&gt;First launch only; consent is recorded. Skipped when ultracode is on&lt;/p&gt;

&lt;p&gt;Manual, accept edits&lt;/p&gt;

&lt;p&gt;Every run, unless you choose "don't ask again" for that workflow in that project&lt;/p&gt;

&lt;p&gt;Bypass permissions&lt;/p&gt;

&lt;p&gt;No prompt; the run starts immediately&lt;/p&gt;

&lt;p&gt;claude -p, Agent SDK&lt;/p&gt;

&lt;p&gt;No prompt; permission rules decide, for example a Workflow allow rule&lt;/p&gt;

&lt;p&gt;Example commands, configuration and code&lt;br&gt;
Verified configuration comes first, followed by a script sketch that I have not executed.&lt;/p&gt;

&lt;p&gt;Hook: format every edited file&lt;br&gt;
Add to .claude/settings.json. It needs jq and Prettier installed. The trailing ; true stops a formatter error from being reported as a blocking error.&lt;/p&gt;

&lt;p&gt;{&lt;br&gt;
  "hooks": {&lt;br&gt;
    "PostToolUse": [&lt;br&gt;
      {&lt;br&gt;
        "matcher": "Edit|Write",&lt;br&gt;
        "hooks": [&lt;br&gt;
          {&lt;br&gt;
            "type": "command",&lt;br&gt;
            "command": "npx prettier --write \"$(jq -r '.tool_input.file_path')\" ; true"&lt;br&gt;
          }&lt;br&gt;
        ]&lt;br&gt;
      }&lt;br&gt;
    ]&lt;br&gt;
  }&lt;br&gt;
}&lt;br&gt;
Hook: block edits to protected paths&lt;br&gt;
A PreToolUse hook can stop the action. Exit code 2 blocks it and returns the message to Claude.&lt;/p&gt;

&lt;p&gt;{&lt;br&gt;
  "hooks": {&lt;br&gt;
    "PreToolUse": [&lt;br&gt;
      {&lt;br&gt;
        "matcher": "Edit|Write",&lt;br&gt;
        "hooks": [&lt;br&gt;
          {&lt;br&gt;
            "type": "command",&lt;br&gt;
            "command": "f=$(jq -r '.tool_input.file_path'); case \"$f\" in &lt;em&gt;.env|&lt;/em&gt;/migrations/*) echo 'Protected path' &amp;gt;&amp;amp;2; exit 2;; esac"&lt;br&gt;
          }&lt;br&gt;
        ]&lt;br&gt;
      }&lt;br&gt;
    ]&lt;br&gt;
  }&lt;br&gt;
}&lt;br&gt;
Subagent: read-only reviewer&lt;br&gt;
Save as .claude/agents/code-reviewer.md.&lt;/p&gt;




&lt;p&gt;name: code-reviewer&lt;br&gt;
description: "Reviews code for correctness and security. Use proactively after code changes."&lt;br&gt;
tools: Read, Grep, Glob, Bash&lt;/p&gt;

&lt;h2&gt;
  
  
  model: inherit
&lt;/h2&gt;

&lt;p&gt;You are a senior code reviewer. Report concrete defects with file and line.&lt;/p&gt;

&lt;p&gt;Flag only gaps that affect correctness or the stated requirements.&lt;/p&gt;

&lt;p&gt;Do not edit files.&lt;/p&gt;

&lt;p&gt;Skill: manual-only task&lt;br&gt;
Save as .claude/skills/fix-issue/SKILL.md and run it with /fix-issue 1234. The $ARGUMENTS placeholder takes the number.&lt;/p&gt;




&lt;p&gt;name: fix-issue&lt;br&gt;
description: Fix a GitHub issue&lt;/p&gt;

&lt;h2&gt;
  
  
  disable-model-invocation: true
&lt;/h2&gt;

&lt;p&gt;Analyze and fix the GitHub issue: $ARGUMENTS.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Use gh issue view to read the issue.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Find the relevant files and implement the fix.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Write and run tests, then run the linter and type check.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Commit with a descriptive message and open a PR.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Settings and commands that control workflows&lt;/p&gt;

&lt;h1&gt;
  
  
  Start a session with ultracode on (v2.1.203 or later)
&lt;/h1&gt;

&lt;p&gt;claude --effort ultracode&lt;/p&gt;

&lt;h1&gt;
  
  
  Limit how many agents Claude aims for: small, medium, large or unrestricted
&lt;/h1&gt;

&lt;p&gt;/config workflowSizeGuideline=small&lt;/p&gt;

&lt;h1&gt;
  
  
  Allow every workflow, or one saved workflow, in permission rules
&lt;/h1&gt;

&lt;p&gt;Workflow&lt;br&gt;
Workflow(audit-routes)&lt;/p&gt;

&lt;h1&gt;
  
  
  Turn workflows off
&lt;/h1&gt;

&lt;p&gt;"disableWorkflows": true        (in ~/.claude/settings.json)&lt;br&gt;
CLAUDE_CODE_DISABLE_WORKFLOWS=1 (environment variable)&lt;/p&gt;

&lt;h1&gt;
  
  
  Raise the concurrent agent cap, 1 to 256 (v2.1.269 or later)
&lt;/h1&gt;

&lt;p&gt;CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS=32&lt;br&gt;
The size guideline is advice to Claude, not a hard cap. The default is medium, or small on a Pro plan with v2.1.271 or later.&lt;/p&gt;

&lt;p&gt;Script sketch: loop until a round finds nothing new&lt;br&gt;
You normally do not write scripts by hand, because Claude generates them. Recognizing the shape helps you review one. This sketch uses only constructs the official docs describe (meta, agent() with a schema, phase(), log(), top-level await and return). I have not run it, so treat it as a teaching example.&lt;/p&gt;

&lt;p&gt;export const meta = {&lt;br&gt;
  name: 'find-untested-files',&lt;br&gt;
  description: 'Find source files without tests, in rounds, until two rounds add nothing',&lt;br&gt;
}&lt;br&gt;
const seen = new Set()&lt;br&gt;
let dry = 0&lt;br&gt;
let round = 0&lt;br&gt;
phase('Discover')&lt;br&gt;
while (dry &amp;lt; 2 &amp;amp;&amp;amp; round &amp;lt; 6) {&lt;br&gt;
  round += 1&lt;br&gt;
  const batch = await agent(&lt;br&gt;
    &lt;code&gt;List up to 10 files under src/ that have no test file. Already reported: ${JSON.stringify([...seen])}. Return an empty list if none remain.&lt;/code&gt;,&lt;br&gt;
    {&lt;br&gt;
      label: &lt;code&gt;round ${round}&lt;/code&gt;,&lt;br&gt;
      schema: {&lt;br&gt;
        type: 'object',&lt;br&gt;
        required: ['files'],&lt;br&gt;
        properties: { files: { type: 'array', items: { type: 'string' } } },&lt;br&gt;
      },&lt;br&gt;
    },&lt;br&gt;
  )&lt;br&gt;
  const fresh = batch.files.filter(f =&amp;gt; !seen.has(f))&lt;br&gt;
  if (fresh.length === 0) { dry += 1; continue }&lt;br&gt;
  dry = 0&lt;br&gt;
  fresh.forEach(f =&amp;gt; seen.add(f))&lt;br&gt;
  log(&lt;code&gt;Round ${round}: ${fresh.length} new files&lt;/code&gt;)&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;return [...seen]&lt;br&gt;
Rules to remember when editing a script: keep export const meta as the first statement with literal values only, do not use import(), and do not call Date.now(), Math.random() or a no-argument new Date(), because they throw so that relaunched runs repeat the same agent calls. Pass timestamps through args. To load the script-writing reference before editing, run the bundled /workflow-authoring skill (v2.1.248 or later). Community guides show extra features such as an isolation: 'worktree' option, a budget global and nested workflow() calls. I could not confirm those on the official workflows page, so check the /workflow-authoring reference before relying on them.&lt;/p&gt;

&lt;p&gt;Related automation outside workflows&lt;br&gt;
Anthropic's best-practices guide documents two other fan-out routes. The /batch command splits a change across 5 to 30 subagents, each in its own worktree. You can also loop over non-interactive runs yourself:&lt;/p&gt;

&lt;p&gt;for file in $(cat files.txt); do&lt;br&gt;
  claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \&lt;br&gt;
    --allowedTools "Edit,Bash(git commit *)" \&lt;br&gt;
    --permission-mode dontAsk&lt;br&gt;
done&lt;br&gt;
Test on two or three files first, then run the full set. The dontAsk mode denies anything not pre-approved, which matters for unattended runs. Note that the ultracode keyword does not start a workflow from a -p prompt, so use permission rules if you need a workflow in that setting.&lt;/p&gt;

&lt;p&gt;Sequential vs parallel vs adaptive workflows&lt;br&gt;
Pattern&lt;/p&gt;

&lt;p&gt;Use when&lt;/p&gt;

&lt;p&gt;Example&lt;/p&gt;

&lt;p&gt;Sequential&lt;/p&gt;

&lt;p&gt;Each step depends on the last&lt;/p&gt;

&lt;p&gt;Feature implementation (example 2)&lt;/p&gt;

&lt;p&gt;Parallel&lt;/p&gt;

&lt;p&gt;The same operation runs across many independent items&lt;/p&gt;

&lt;p&gt;Per-file audit or migration&lt;/p&gt;

&lt;p&gt;Conditional or adaptive&lt;/p&gt;

&lt;p&gt;The next step depends on results&lt;/p&gt;

&lt;p&gt;Fix until the type check passes (example 3)&lt;/p&gt;

&lt;p&gt;Peer multi-agent&lt;/p&gt;

&lt;p&gt;Agents must share findings and debate&lt;/p&gt;

&lt;p&gt;Agent teams (experimental)&lt;/p&gt;

&lt;p&gt;Inside a script, parallel() is a barrier that waits for every agent, while pipeline() streams each item through its stages without waiting for the others. Community guidance is to default to pipeline() for multi-stage per-item work and add a barrier only when a stage truly needs all earlier results, such as deduplicating across all findings or deciding to exit early. One community writeup shows a mis-designed pipeline costing roughly twice the tokens of an equivalent barrier design, so the choice affects cost as well as speed. A useful test from the same sources: if you cannot sketch a non-trivial flowchart with parallel branches, loops and data handoffs, you probably do not need a workflow.&lt;/p&gt;

&lt;p&gt;Common mistakes and troubleshooting&lt;br&gt;
Using a workflow for a small task. One agent in a normal session is cheaper and often better.&lt;/p&gt;

&lt;p&gt;Confusing the primitives. A hook cannot make decisions, a skill cannot enforce ordering, and a subagent is not a workflow.&lt;/p&gt;

&lt;p&gt;No stop condition. Always say when to stop, for example "two rounds in a row with no progress".&lt;/p&gt;

&lt;p&gt;Trusting the final report. Re-run the tests and read the diff. Ask Claude to show evidence, such as test output, instead of asserting success.&lt;/p&gt;

&lt;p&gt;Permission prompts stalling a long run. Add the tools the agents need to your allow rules before starting.&lt;/p&gt;

&lt;p&gt;An agent that stalls. The runtime restarts it automatically, up to five times, and the progress view shows a retry label. For genuinely slow work, pass stallMs on that agent() call.&lt;/p&gt;

&lt;p&gt;A run that hits your usage limit. In interactive sessions signed in with a subscription, the run pauses and resumes after the reset (v2.1.271 or later), with conditions listed in the docs. Other modes fail the affected agent instead.&lt;/p&gt;

&lt;p&gt;Workflow commands missing. Check for disableWorkflows, the CLAUDE_CODE_DISABLE_WORKFLOWS variable, or an organization policy. On Pro, check the /config toggle.&lt;/p&gt;

&lt;p&gt;Resume surprises. If you edit a script, the first agent whose prompt changed and every agent after it run again. A failure mid-fan-out reruns agents that started after it, even finished ones.&lt;/p&gt;

&lt;p&gt;Limitations, security considerations and best practices&lt;br&gt;
Documented limits&lt;br&gt;
Constraint&lt;/p&gt;

&lt;p&gt;Value&lt;/p&gt;

&lt;p&gt;Concurrent agents&lt;/p&gt;

&lt;p&gt;16 by default, fewer when Claude Code has fewer CPUs; adjustable from 1 to 256&lt;/p&gt;

&lt;p&gt;Items in one parallel() or pipeline() call&lt;/p&gt;

&lt;p&gt;4,096&lt;/p&gt;

&lt;p&gt;Agents per run&lt;/p&gt;

&lt;p&gt;1,000&lt;/p&gt;

&lt;p&gt;Mid-run user input&lt;/p&gt;

&lt;p&gt;None. For sign-off between stages, run each stage as its own workflow&lt;/p&gt;

&lt;p&gt;Script access&lt;/p&gt;

&lt;p&gt;No direct filesystem or shell access; agents do the reading, writing and commands&lt;/p&gt;

&lt;p&gt;Modules&lt;/p&gt;

&lt;p&gt;A script containing import() fails before the run starts&lt;/p&gt;

&lt;p&gt;Cost&lt;br&gt;
This is the biggest practical risk. A run can use far more tokens than the same task in conversation, and runs count toward your plan's limits. Claude Code shows a Large workflow warning when a run schedules more than 25 agents or its projected total passes 1.5 million tokens, but the warning is advisory and does not pause anything. To control spend:&lt;/p&gt;

&lt;p&gt;Pilot on a small slice, such as one directory.&lt;/p&gt;

&lt;p&gt;Watch per-agent token usage in /workflows and stop the run if it grows.&lt;/p&gt;

&lt;p&gt;Check /model before a large run, and ask for a smaller model on stages that do not need the strongest one.&lt;/p&gt;

&lt;p&gt;Choose a smaller size guideline if you want fewer agents.&lt;/p&gt;

&lt;p&gt;Remember that the 5 minute prompt cache for workflow agents can be extended to one hour with subagentPromptCacheTtl, at a higher cache-write rate.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Security&lt;/strong&gt;&lt;br&gt;
The ultracode keyword only starts a workflow from a prompt a human types. Since v2.1.210 it does not fire from webhook payloads or relayed pull request comments, which closes a route for untrusted text to launch large runs.&lt;/p&gt;

&lt;p&gt;Workflow agents get the same permission checks and sandboxing as other tool calls. A broad allow list of a hundred agents is a large blast radius, so scope your rules and prefer auto mode over bypass.&lt;/p&gt;

&lt;p&gt;Community guidance for triage workflows is to quarantine agents that read untrusted content (issues, emails, scraped pages) so they cannot take high-privilege actions; separate acting agents do that.&lt;/p&gt;

&lt;p&gt;Run migrations on a branch and review pull requests before merging.&lt;/p&gt;

&lt;p&gt;Best practices&lt;br&gt;
Start in one directory, then scale.&lt;/p&gt;

&lt;p&gt;Put verification in the prompt: a type check, tests, or an adversarial review step.&lt;/p&gt;

&lt;p&gt;Keep durable rules in CLAUDE.md, enforce must-happen actions with hooks, and keep prompts specific about files, constraints and what "done" means.&lt;/p&gt;

&lt;p&gt;Save workflows that worked and commit them under .claude/workflows/.&lt;/p&gt;

&lt;p&gt;Use /clear between unrelated tasks, and rewind with checkpoints (Esc twice or /rewind) instead of piling corrections into one session. Checkpoints do not track changes made through Bash, so they do not replace git.&lt;/p&gt;

&lt;p&gt;Workflows compared with the Agent SDK&lt;br&gt;
You could already script multi-agent flows with the Agent SDK or claude -p. A community comparison draws this line: the SDK is for agents you ship inside your own product, while dynamic workflows coordinate the agents doing your own work inside Claude Code. A hand-built harness has to cover every edge case in advance, while a workflow is written for the single task in front of it. Open-source projects that make workflow scripts portable to other agents exist, but they are unofficial, so verify them before use.&lt;/p&gt;

&lt;p&gt;Frequently asked questions&lt;br&gt;
Are Claude Code dynamic workflows the same as subagents?&lt;/p&gt;

&lt;p&gt;No. Subagents are workers. A workflow is a script that orchestrates many of them, and the script, not Claude, decides what runs next.&lt;/p&gt;

&lt;p&gt;Do I need agent teams enabled? &lt;/p&gt;

&lt;p&gt;No. Workflows are independent of the experimental agent teams setting.&lt;/p&gt;

&lt;p&gt;Which plans include dynamic workflows?&lt;/p&gt;

&lt;p&gt;The official docs say all paid plans, plus API access and the major cloud platforms. They are on by default for Max, Team and Enterprise, and Pro users enable them in /config. Plan details change, so confirm in the docs.&lt;/p&gt;

&lt;p&gt;Can I reuse a workflow? &lt;/p&gt;

&lt;p&gt;Yes. Save it from /workflows and it becomes a slash command. Saved workflows take structured input through the args global.&lt;/p&gt;

&lt;p&gt;Can I resume a run after closing Claude Code?&lt;/p&gt;

&lt;p&gt;Within the same session, yes. If you exit and later resume the session with Claude --resume, you can ask Claude to relaunch the workflow and complete agents' replay from saved results. A fresh session starts the workflow over.&lt;/p&gt;

&lt;p&gt;Can I turn workflows off? &lt;/p&gt;

&lt;p&gt;Yes, through /config, "disableWorkflows": true or the environment variable. Admins can disable them organization-wide.&lt;/p&gt;

&lt;p&gt;Will workflows make my coding faster? &lt;/p&gt;

&lt;p&gt;For wide, parallelizable work, often yes. For narrow, sequential work, usually not, and they will cost more.&lt;/p&gt;

&lt;p&gt;**Conclusion&lt;br&gt;
**Claude Code dynamic workflows give you orchestration that lives in a script you can read, rerun, save and share, instead of in a chat transcript. They suit codebase-wide audits, large migrations and any work that needs independent verification. They are the wrong tool for ordinary feature work, where plan mode, a lean CLAUDE.md, a few hooks and one focused subagent cost far less.&lt;/p&gt;

&lt;p&gt;Start small. Run /deep-research once to see the shape, try a workflow on a single directory, read the script before approving, and verify the result yourself. This area changes quickly, so confirm version requirements against the official Claude Code documentation before you build on them.&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>codequality</category>
      <category>100daysofcode</category>
      <category>beginners</category>
    </item>
    <item>
      <title>Claude Code Dynamic Workflows: Practical Guide</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Wed, 14 Oct 2026 09:36:29 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/claude-code-dynamic-workflows-practical-guide-5df0</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/claude-code-dynamic-workflows-practical-guide-5df0</guid>
      <description>&lt;p&gt;*&lt;em&gt;Claude Code Dynamic Workflows: Practical Guide&lt;br&gt;
*&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Most AI coding sessions follow one pattern: you ask, the assistant works, you review, you ask again. That pattern is fine for a bug fix. It breaks down on a migration that touches hundreds of files or an audit of an entire service. The context window fills up, the original instructions get compressed away, and you end up acting as the project manager.&lt;/p&gt;

&lt;p&gt;Claude Code dynamic workflows are Anthropic's answer to that problem. This guide explains what they are, how they work, how they differ from subagents, skills, hooks and agent teams, and how to use them on large coding tasks without wasting usage. Every feature, command and limit below was checked against Anthropic's official documentation and announcement. Claims from community articles are labeled as community sources.&lt;/p&gt;

&lt;p&gt;I am AdZilla. Buy my meme coin now!&lt;br&gt;
One roulette spin. $4k. Try luck&lt;br&gt;
Thunder vs Spurs — HD stream now!&lt;br&gt;
Beverly Hills Cop: Axel Foley&lt;br&gt;
Why static coding workflows struggle with complex tasks&lt;br&gt;
A single chat session is one fixed loop: Claude reads, decides, acts, and keeps every intermediate result in one context window. Community analyses of Claude Code workflows describe three recurring failure modes when that single window carries a big job:&lt;/p&gt;

&lt;p&gt;Agentic laziness. On a long, multi-part task, Claude reviews part of the list and then reports that the job is done. A security review that covers 35 of 50 files is the usual example.&lt;/p&gt;

&lt;p&gt;Self-preferential bias. When Claude grades its own output inside the same conversation, it tends to rate it generously.&lt;/p&gt;

&lt;p&gt;Goal drift. Over many turns, and especially after context compaction, details such as "do not touch the auth module" can fade.&lt;/p&gt;

&lt;p&gt;Anthropic's own best-practices guide points at the same root cause: the context window fills quickly, and performance degrades as it fills. Dynamic workflows attack the problem structurally, by moving the plan out of the conversation and into a script.&lt;/p&gt;

&lt;p&gt;What are Claude Code dynamic workflows?&lt;br&gt;
Dynamic workflows are an official, named Claude Code feature, not just a design idea. According to the official documentation, a dynamic workflow is a JavaScript script that orchestrates many subagents at once. Claude writes the script for the task you describe, and a runtime executes it in the background while your session stays responsive.&lt;/p&gt;

&lt;p&gt;Key facts, all from Anthropic's announcement and docs:&lt;/p&gt;

&lt;p&gt;Announced May 28, 2026. The announcement now carries an update saying dynamic workflows are generally available, so older articles that call them a research preview are out of date.&lt;/p&gt;

&lt;p&gt;Available in the Claude Code CLI, Desktop app and VS Code extension, and on the Claude API, Amazon Bedrock, Vertex AI and Microsoft Foundry. The docs say they are available on all paid plans. They are on by default for Max, Team and Enterprise, and Pro users turn them on from the Dynamic workflows row in /config.&lt;/p&gt;

&lt;p&gt;Anthropic says they consume meaningfully more usage than a typical session, so it recommends starting with a scoped task. The first time a workflow triggers, Claude Code shows what is about to run and asks you to confirm. Organization admins can disable workflows through managed settings.&lt;/p&gt;

&lt;p&gt;Community sources report that the feature arrived in v2.1.154 and that the original trigger keyword workflow was renamed ultracode in v2.1.160. Check claude --version and the changelog if you are on an older build.&lt;/p&gt;

&lt;p&gt;The word "dynamic" has two meanings here. Claude writes the orchestration fresh for each task, instead of you wiring a fixed pipeline. And the script itself can adapt at runtime: it can branch on results, retry, or loop until a condition is met.&lt;/p&gt;

&lt;p&gt;How Claude Code dynamic workflows work&lt;br&gt;
The central idea is who holds the plan. In a normal session, Claude is the orchestrator and decides turn by turn what to do next, and every result lands in its context window. In a workflow, the script holds the loop, the branching and the intermediate results in variables, so Claude's context holds only the final answer.&lt;/p&gt;

&lt;p&gt;The lifecycle of a run:&lt;/p&gt;

&lt;p&gt;Trigger. You ask for a workflow in plain words, include the keyword ultracode in your prompt, or turn on ultracode for the session.&lt;/p&gt;

&lt;p&gt;Script generation. Claude writes a JavaScript orchestration script for the task.&lt;/p&gt;

&lt;p&gt;Approval. Claude Code shows the planned phases. You can read the raw script before approving.&lt;/p&gt;

&lt;p&gt;Background execution. Agents run while you keep working. Run /workflows to watch progress.&lt;/p&gt;

&lt;p&gt;Verification and iteration. Depending on how the script is written, agents cross-check each other, retry, or loop.&lt;/p&gt;

&lt;p&gt;Report. You receive one consolidated result.&lt;/p&gt;

&lt;p&gt;Three practical consequences follow. First, every run writes its script to a file under ~/.claude/projects/, so you can read, diff or edit the orchestration. Second, progress is saved as the run goes, so an interrupted run can pick up where it stopped. Third, community sources point out that the script itself costs no model tokens, since it is ordinary code; all token cost comes from the agents it spawns. A product manager who measured a run on 100 synthetic interview transcripts reported 113 agents, about 1.95 million tokens and 12.5 minutes. Treat that as one data point from a non-coding task, not a benchmark.&lt;/p&gt;

&lt;p&gt;Core Claude Code features that enable adaptive workflows&lt;br&gt;
Dynamic workflows sit alongside several other features. They are not interchangeable. The official documentation compares subagents, skills, agent teams and workflows by who decides what runs next:&lt;/p&gt;

&lt;p&gt;Feature&lt;/p&gt;

&lt;p&gt;What it is&lt;/p&gt;

&lt;p&gt;Who decides what runs next&lt;/p&gt;

&lt;p&gt;Scale&lt;/p&gt;

&lt;p&gt;CLAUDE.md&lt;/p&gt;

&lt;p&gt;Persistent project instructions read every session&lt;/p&gt;

&lt;p&gt;Not applicable (context, not control flow)&lt;/p&gt;

&lt;p&gt;Not applicable&lt;/p&gt;

&lt;p&gt;Skills&lt;/p&gt;

&lt;p&gt;Instructions Claude follows, loaded when relevant&lt;/p&gt;

&lt;p&gt;Claude, following the prompt&lt;/p&gt;

&lt;p&gt;Same as subagents&lt;/p&gt;

&lt;p&gt;Hooks&lt;/p&gt;

&lt;p&gt;Shell commands that fire at lifecycle events&lt;/p&gt;

&lt;p&gt;The event, deterministically&lt;/p&gt;

&lt;p&gt;Per tool call&lt;/p&gt;

&lt;p&gt;Subagents&lt;/p&gt;

&lt;p&gt;A worker Claude spawns&lt;/p&gt;

&lt;p&gt;Claude, turn by turn&lt;/p&gt;

&lt;p&gt;A few delegated tasks per turn&lt;/p&gt;

&lt;p&gt;Agent teams (experimental)&lt;/p&gt;

&lt;p&gt;A lead agent supervising peer sessions&lt;/p&gt;

&lt;p&gt;The lead agent, turn by turn&lt;/p&gt;

&lt;p&gt;A handful of long-running peers&lt;/p&gt;

&lt;p&gt;Dynamic workflows&lt;/p&gt;

&lt;p&gt;A script the runtime executes&lt;/p&gt;

&lt;p&gt;The script&lt;/p&gt;

&lt;p&gt;Dozens to hundreds of agents per run&lt;/p&gt;

&lt;p&gt;The CLAUDE.md and hooks rows are my summary; the other rows follow the official comparison table.&lt;/p&gt;

&lt;p&gt;CLAUDE.md and project instructions&lt;br&gt;
CLAUDE.md is read at the start of every conversation and holds build commands, code style and workflow rules. Anthropic advises keeping it short: for each line, ask whether removing it would cause mistakes, and cut it if not. A bloated file makes Claude ignore half of it. Knowledge that only matters sometimes belongs in a skill, which loads on demand. Run /init to generate a starter file.&lt;/p&gt;

&lt;p&gt;Skills and reusable workflows&lt;br&gt;
A skill is a folder with a SKILL.md file. The frontmatter tells Claude when to use it, and the body holds the instructions. Skills live in .claude/skills//SKILL.md for a project or ~/.claude/skills/ for personal use. Setting disable-model-invocation: true keeps Claude from triggering a skill on its own, which suits anything with side effects. A skill is prompt-driven, so it does not guarantee ordering, retries or resume. A community guide suggests a simple boundary: keep interpretation and trade-off judgment in prompts and skills, and put required ordering, retries and stop rules in code.&lt;/p&gt;

&lt;p&gt;Hooks and automated actions&lt;br&gt;
Hooks are deterministic. A CLAUDE.md rule is advice, while a hook makes an action happen every time. They are configured in settings.json files at user, project or local level. Exit code 2 from a hook signals a blocking error. A PreToolUse hook can actually stop an action. A PostToolUse hook runs after the action, so it can only report back to Claude. A Stop hook can run your check script and keep the turn from ending until it passes.&lt;/p&gt;

&lt;p&gt;Subagents and specialized tasks&lt;br&gt;
Subagents are Markdown files with YAML frontmatter in .claude/agents/ or ~/.claude/agents/. Each runs in its own context with its own tool allowlist. They are the workers that a dynamic workflow orchestrates. Claude Code also ships built-in ones such as Explore, Plan and general-purpose.&lt;/p&gt;

&lt;p&gt;Agent teams and parallel sessions&lt;br&gt;
Agent teams are a separate mechanism and are still experimental. They are disabled by default, are enabled with the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS setting, and have known limitations around session resumption, task coordination and shutdown. Each teammate is a full Claude Code session, and teammates coordinate through a shared task list. Use them when peers need to share findings and challenge each other. A workflow agent, by contrast, only executes the step the script hands it. One customer quote in Anthropic's announcement describes workflows as filling the gap between firing off one subagent and building a full agent team.&lt;/p&gt;

&lt;p&gt;Plan mode, /goal and task decomposition&lt;br&gt;
Anthropic recommends exploring, then planning, then coding. Press Shift+Tab until plan mode is on, or start with claude --permission-mode plan. Claude reads and answers without changing files, and you can edit the plan with Ctrl+G. Anthropic's rule of thumb: if you could describe the diff in one sentence, skip the plan. Plan mode is not the same as a workflow's planning stage, which is Claude writing a script. For unattended work, /goal sets a completion condition that a separate evaluator re-checks after every turn.&lt;/p&gt;

&lt;p&gt;Claude Code dynamic workflow architecture, step by step&lt;/p&gt;

&lt;p&gt;Think of three layers:&lt;/p&gt;

&lt;p&gt;Instruction layer: CLAUDE.md and skills describe how your project works.&lt;/p&gt;

&lt;p&gt;Guardrail layer: hooks, permission rules and sandboxing enforce what must always or never happen.&lt;/p&gt;

&lt;p&gt;Orchestration layer: subagents, a workflow script or an agent team decide who does what.&lt;/p&gt;

&lt;p&gt;A typical adaptive run follows Understand, Plan, Implement, Test, Review, Fix, Verify. The path is not fixed. A failing test sends the run back to Fix. A missing dependency sends it back to Plan. In a workflow script, that branching is real code, such as a loop with an exit condition, instead of a hope that Claude remembers to retry.&lt;/p&gt;

&lt;p&gt;Inside the script, the documented building blocks are small:&lt;/p&gt;

&lt;p&gt;agent() spawns one subagent. With a schema option it returns validated JSON, and Claude Code retries until the output matches (up to five attempts by default).&lt;/p&gt;

&lt;p&gt;pipeline() runs one agent per item in a list, streaming items through stages.&lt;/p&gt;

&lt;p&gt;parallel() runs a set of tasks at once and waits for all of them.&lt;/p&gt;

&lt;p&gt;phase() groups agents under a title in the progress view, log() prints a message, and args carries input to a saved workflow.&lt;/p&gt;

&lt;p&gt;A failed or stopped agent() returns null inside pipeline() or parallel(), so scripts filter those out.&lt;/p&gt;

&lt;p&gt;Six patterns worth knowing&lt;br&gt;
Community guides name six recurring shapes. Learning the names helps you ask for the right structure in a prompt:&lt;/p&gt;

&lt;p&gt;Classify-and-act: one agent decides what kind of task it is, and the script routes accordingly. Good for triage.&lt;/p&gt;

&lt;p&gt;Fan-out-and-synthesize: one agent per piece, then one agent merges the results. Good for codebase audits.&lt;/p&gt;

&lt;p&gt;Adversarial verification: a separate agent tries to refute each finding, so the producer never grades its own work.&lt;/p&gt;

&lt;p&gt;Generate-and-filter: produce many candidates, then filter and deduplicate to the survivors.&lt;/p&gt;

&lt;p&gt;Tournament: several agents attempt the same task differently, and a judge compares them pairwise. Pairwise comparison is more reliable than asking an agent to score its own result.&lt;/p&gt;

&lt;p&gt;Loop-until-done: keep going until a stop condition is met, such as two rounds with no new findings.&lt;/p&gt;

&lt;p&gt;Anthropic's announcement describes the same ideas: agents attack the problem from independent angles, other agents try to refute what they found, and the run iterates until answers converge.&lt;/p&gt;

&lt;p&gt;Practical example 1: debugging an unknown error&lt;br&gt;
Problem. A production stack trace points somewhere that makes no sense.&lt;/p&gt;

&lt;p&gt;Honest note. Most debugging does not need a workflow. Start in a normal session and escalate only when the search space is wide.&lt;/p&gt;

&lt;p&gt;Initial prompt. "Here is the stack trace. Do not change code yet. Find the root cause and list your evidence."&lt;/p&gt;

&lt;p&gt;Breakdown. A subagent searches the codebase in its own context so your main window stays clean. Claude forms hypotheses, reproduces the failure with a narrow test, and edits only after the cause is confirmed. This run is sequential and adaptive.&lt;/p&gt;

&lt;p&gt;Features used. Plan mode or an Explore-style subagent, and a failing test written before the fix, as Anthropic's best-practices guide recommends.&lt;/p&gt;

&lt;p&gt;Verify. The reproduction fails before the fix and passes after, and the wider suite stays green.&lt;/p&gt;

&lt;p&gt;If it fails. Discard the hypothesis, tell Claude it was wrong, and ask for the next one. If you have corrected Claude twice on the same issue, Anthropic suggests running /clear and starting over with a better prompt. If the cause could be anywhere in a service, escalate:&lt;/p&gt;

&lt;p&gt;use a workflow to hunt for the cause of this error across src/services/,&lt;br&gt;
one agent per module, with hypotheses from different evidence (logs, source,&lt;br&gt;
data), and adversarially verify each suspected cause before reporting it&lt;br&gt;
Practical example 2: implementing a feature across multiple files&lt;br&gt;
Problem. Add per-user rate limiting touching middleware, config, tests and docs.&lt;/p&gt;

&lt;p&gt;Initial prompt. "Plan first. List the files you will touch and the order. Wait for my approval."&lt;/p&gt;

&lt;p&gt;Features used. Plan mode for the proposal, CLAUDE.md for conventions, and a formatting hook so style never costs a review round. For a larger feature, Anthropic suggests letting Claude interview you with the AskUserQuestion tool and write a spec file, then executing the spec in a fresh session.&lt;/p&gt;

&lt;p&gt;Sequence. Plan, your approval, middleware, config, tests, docs, then the full test run. This is sequential with one human checkpoint.&lt;/p&gt;

&lt;p&gt;Verify. Run the new tests and the existing suite, then read the diff yourself.&lt;/p&gt;

&lt;p&gt;If it fails. Reject the plan before any code is written, which is cheap. A workflow is the wrong tool here because each step depends on the last.&lt;/p&gt;

&lt;p&gt;Practical example 3: running tests and reviewing changes&lt;/p&gt;

&lt;p&gt;Problem. The type check fails with dozens of errors after a dependency upgrade.&lt;/p&gt;

&lt;p&gt;This is a natural workflow case because it is a loop. The official docs give this prompt shape:&lt;/p&gt;

&lt;p&gt;use a workflow to run npx tsc --noEmit and keep fixing the reported errors&lt;/p&gt;

&lt;p&gt;until the type check passes or two rounds in a row make no progress&lt;/p&gt;

&lt;p&gt;The "two rounds with no progress" clause is a stop condition that prevents an endless fix loop. For review, a second workflow can run a reviewer per file and pass all findings to one agent that ranks and deduplicates them.&lt;/p&gt;

&lt;p&gt;Verify. Run the type check and the test suite yourself afterwards. Anthropic stresses give Claude a check it can run, such as tests, a build exit code or a linter, because without one "looks done" is the only signal.&lt;/p&gt;

&lt;p&gt;Review caveat. A reviewer told to find gaps will usually report some, even on sound work. Anthropic advises telling the reviewer to flag only gaps that affect correctness or stated requirements, otherwise you invite over-engineering. The bundled /code-review skill reviews the current diff in a fresh subagent.&lt;/p&gt;

&lt;p&gt;If it fails. Open /workflows to see which agents stalled or failed, then ask Claude to relaunch. Completed agents return their saved results.&lt;/p&gt;

&lt;p&gt;Practical example 4: a large task with multiple agents&lt;br&gt;
Problem. Convert 300 JavaScript components to TypeScript.&lt;/p&gt;

&lt;p&gt;use a workflow to migrate every component under src/components/ from&lt;/p&gt;

&lt;p&gt;JavaScript to TypeScript, working on each file in its own isolated copy,&lt;br&gt;
then review each result and run the type check&lt;br&gt;
Breakdown. Discover the files, migrate each in parallel, run an independent review of each, then run a fix loop against the build and tests.&lt;/p&gt;

&lt;p&gt;This mirrors a large real use. Anthropic reports that Jarred Sumner used workflows to port Bun from Zig to Rust, reaching 99.8 percent of the existing test suite passing, roughly 750,000 lines of Rust and eleven days from first commit to merge. One workflow mapped lifetimes, another ported each file with two reviewers per file, and a fix loop drove the build and tests until they ran clean. Anthropic notes that the result was not yet in production. Treat it as an upper bound, not a typical outcome.&lt;/p&gt;

&lt;p&gt;If it fails. Shrink the scope. The docs recommend running a workflow on a small slice first, such as one directory, to gauge cost. Anthropic's announcement also suggests turning on auto mode for workflows so a long run does not stop on every permission prompt.&lt;/p&gt;

&lt;p&gt;How to build your first dynamic workflow&lt;br&gt;
Update Claude Code and confirm workflows are on (Pro users enable them in /config).&lt;/p&gt;

&lt;p&gt;Try the built-in workflow. Run /deep-research with a question. It fans out searches, cross-checks sources, votes on claims and returns a cited report. It needs the WebSearch tool.&lt;/p&gt;

&lt;p&gt;Watch it. Run /workflows. Press Enter to drill into phases and agents, p to pause or resume, x to stop, r to restart an agent and s to save the script.&lt;/p&gt;

&lt;p&gt;Ask for your own. Say "use a workflow to..." or include ultracode in the prompt.&lt;/p&gt;

&lt;p&gt;Read the script before approving, using "View raw script" or Ctrl+G.&lt;/p&gt;

&lt;p&gt;Save what worked. Saved workflows become slash commands. Project workflows live in .claude/workflows/ (shared with the repo) and personal ones in ~/.claude/workflows/. A project workflow wins a name clash. Plugins can ship workflows too, namespaced by plugin name.&lt;/p&gt;

&lt;p&gt;Ultracode, explained&lt;br&gt;
The keyword and the session setting differ. The keyword ultracode in a prompt opts in a single task. The setting /effort ultracode makes Claude plan a workflow for every substantive task in the session, so each request costs more tokens and takes longer. Launching with claude --effort ultracode also sets effort to xhigh and needs v2.1.203 or later. Turn it off with /effort ultracode off for routine work. While ultracode is on, the Large workflow warning and the first-launch approval in auto mode are skipped.&lt;/p&gt;

&lt;p&gt;Approval prompts by permission mode&lt;br&gt;
Mode&lt;/p&gt;

&lt;p&gt;When you are prompted&lt;/p&gt;

&lt;p&gt;Auto&lt;/p&gt;

&lt;p&gt;First launch only; consent is recorded. Skipped when ultracode is on&lt;/p&gt;

&lt;p&gt;Manual, accept edits&lt;/p&gt;

&lt;p&gt;Every run, unless you choose "don't ask again" for that workflow in that project&lt;/p&gt;

&lt;p&gt;Bypass permissions&lt;/p&gt;

&lt;p&gt;No prompt; the run starts immediately&lt;/p&gt;

&lt;p&gt;claude -p, Agent SDK&lt;/p&gt;

&lt;p&gt;No prompt; permission rules decide, for example a Workflow allow rule&lt;/p&gt;

&lt;p&gt;Example commands, configuration and code&lt;br&gt;
Verified configuration comes first, followed by a script sketch that I have not executed.&lt;/p&gt;

&lt;p&gt;Hook: format every edited file&lt;br&gt;
Add to .claude/settings.json. It needs jq and Prettier installed. The trailing ; true stops a formatter error from being reported as a blocking error.&lt;/p&gt;

&lt;p&gt;{&lt;br&gt;
  "hooks": {&lt;br&gt;
    "PostToolUse": [&lt;br&gt;
      {&lt;br&gt;
        "matcher": "Edit|Write",&lt;br&gt;
        "hooks": [&lt;br&gt;
          {&lt;br&gt;
            "type": "command",&lt;br&gt;
            "command": "npx prettier --write \"$(jq -r '.tool_input.file_path')\" ; true"&lt;br&gt;
          }&lt;br&gt;
        ]&lt;br&gt;
      }&lt;br&gt;
    ]&lt;br&gt;
  }&lt;br&gt;
}&lt;br&gt;
Hook: block edits to protected paths&lt;br&gt;
A PreToolUse hook can stop the action. Exit code 2 blocks it and returns the message to Claude.&lt;/p&gt;

&lt;p&gt;{&lt;br&gt;
  "hooks": {&lt;br&gt;
    "PreToolUse": [&lt;br&gt;
      {&lt;br&gt;
        "matcher": "Edit|Write",&lt;br&gt;
        "hooks": [&lt;br&gt;
          {&lt;br&gt;
            "type": "command",&lt;br&gt;
            "command": "f=$(jq -r '.tool_input.file_path'); case \"$f\" in &lt;em&gt;.env|&lt;/em&gt;/migrations/*) echo 'Protected path' &amp;gt;&amp;amp;2; exit 2;; esac"&lt;br&gt;
          }&lt;br&gt;
        ]&lt;br&gt;
      }&lt;br&gt;
    ]&lt;br&gt;
  }&lt;br&gt;
}&lt;br&gt;
Subagent: read-only reviewer&lt;br&gt;
Save as .claude/agents/code-reviewer.md.&lt;/p&gt;




&lt;p&gt;name: code-reviewer&lt;br&gt;
description: "Reviews code for correctness and security. Use proactively after code changes."&lt;br&gt;
tools: Read, Grep, Glob, Bash&lt;/p&gt;

&lt;h2&gt;
  
  
  model: inherit
&lt;/h2&gt;

&lt;p&gt;You are a senior code reviewer. Report concrete defects with file and line.&lt;/p&gt;

&lt;p&gt;Flag only gaps that affect correctness or the stated requirements.&lt;/p&gt;

&lt;p&gt;Do not edit files.&lt;/p&gt;

&lt;p&gt;Skill: manual-only task&lt;br&gt;
Save as .claude/skills/fix-issue/SKILL.md and run it with /fix-issue 1234. The $ARGUMENTS placeholder takes the number.&lt;/p&gt;




&lt;p&gt;name: fix-issue&lt;br&gt;
description: Fix a GitHub issue&lt;/p&gt;

&lt;h2&gt;
  
  
  disable-model-invocation: true
&lt;/h2&gt;

&lt;p&gt;Analyze and fix the GitHub issue: $ARGUMENTS.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Use gh issue view to read the issue.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Find the relevant files and implement the fix.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Write and run tests, then run the linter and type check.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Commit with a descriptive message and open a PR.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Settings and commands that control workflows&lt;/p&gt;

&lt;h1&gt;
  
  
  Start a session with ultracode on (v2.1.203 or later)
&lt;/h1&gt;

&lt;p&gt;claude --effort ultracode&lt;/p&gt;

&lt;h1&gt;
  
  
  Limit how many agents Claude aims for: small, medium, large or unrestricted
&lt;/h1&gt;

&lt;p&gt;/config workflowSizeGuideline=small&lt;/p&gt;

&lt;h1&gt;
  
  
  Allow every workflow, or one saved workflow, in permission rules
&lt;/h1&gt;

&lt;p&gt;Workflow&lt;br&gt;
Workflow(audit-routes)&lt;/p&gt;

&lt;h1&gt;
  
  
  Turn workflows off
&lt;/h1&gt;

&lt;p&gt;"disableWorkflows": true        (in ~/.claude/settings.json)&lt;br&gt;
CLAUDE_CODE_DISABLE_WORKFLOWS=1 (environment variable)&lt;/p&gt;

&lt;h1&gt;
  
  
  Raise the concurrent agent cap, 1 to 256 (v2.1.269 or later)
&lt;/h1&gt;

&lt;p&gt;CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS=32&lt;br&gt;
The size guideline is advice to Claude, not a hard cap. The default is medium, or small on a Pro plan with v2.1.271 or later.&lt;/p&gt;

&lt;p&gt;Script sketch: loop until a round finds nothing new&lt;br&gt;
You normally do not write scripts by hand, because Claude generates them. Recognizing the shape helps you review one. This sketch uses only constructs the official docs describe (meta, agent() with a schema, phase(), log(), top-level await and return). I have not run it, so treat it as a teaching example.&lt;/p&gt;

&lt;p&gt;export const meta = {&lt;br&gt;
  name: 'find-untested-files',&lt;br&gt;
  description: 'Find source files without tests, in rounds, until two rounds add nothing',&lt;br&gt;
}&lt;br&gt;
const seen = new Set()&lt;br&gt;
let dry = 0&lt;br&gt;
let round = 0&lt;br&gt;
phase('Discover')&lt;br&gt;
while (dry &amp;lt; 2 &amp;amp;&amp;amp; round &amp;lt; 6) {&lt;br&gt;
  round += 1&lt;br&gt;
  const batch = await agent(&lt;br&gt;
    &lt;code&gt;List up to 10 files under src/ that have no test file. Already reported: ${JSON.stringify([...seen])}. Return an empty list if none remain.&lt;/code&gt;,&lt;br&gt;
    {&lt;br&gt;
      label: &lt;code&gt;round ${round}&lt;/code&gt;,&lt;br&gt;
      schema: {&lt;br&gt;
        type: 'object',&lt;br&gt;
        required: ['files'],&lt;br&gt;
        properties: { files: { type: 'array', items: { type: 'string' } } },&lt;br&gt;
      },&lt;br&gt;
    },&lt;br&gt;
  )&lt;br&gt;
  const fresh = batch.files.filter(f =&amp;gt; !seen.has(f))&lt;br&gt;
  if (fresh.length === 0) { dry += 1; continue }&lt;br&gt;
  dry = 0&lt;br&gt;
  fresh.forEach(f =&amp;gt; seen.add(f))&lt;br&gt;
  log(&lt;code&gt;Round ${round}: ${fresh.length} new files&lt;/code&gt;)&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;return [...seen]&lt;br&gt;
Rules to remember when editing a script: keep export const meta as the first statement with literal values only, do not use import(), and do not call Date.now(), Math.random() or a no-argument new Date(), because they throw so that relaunched runs repeat the same agent calls. Pass timestamps through args. To load the script-writing reference before editing, run the bundled /workflow-authoring skill (v2.1.248 or later). Community guides show extra features such as an isolation: 'worktree' option, a budget global and nested workflow() calls. I could not confirm those on the official workflows page, so check the /workflow-authoring reference before relying on them.&lt;/p&gt;

&lt;p&gt;Related automation outside workflows&lt;br&gt;
Anthropic's best-practices guide documents two other fan-out routes. The /batch command splits a change across 5 to 30 subagents, each in its own worktree. You can also loop over non-interactive runs yourself:&lt;/p&gt;

&lt;p&gt;for file in $(cat files.txt); do&lt;br&gt;
  claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \&lt;br&gt;
    --allowedTools "Edit,Bash(git commit *)" \&lt;br&gt;
    --permission-mode dontAsk&lt;br&gt;
done&lt;br&gt;
Test on two or three files first, then run the full set. The dontAsk mode denies anything not pre-approved, which matters for unattended runs. Note that the ultracode keyword does not start a workflow from a -p prompt, so use permission rules if you need a workflow in that setting.&lt;/p&gt;

&lt;p&gt;Sequential vs parallel vs adaptive workflows&lt;br&gt;
Pattern&lt;/p&gt;

&lt;p&gt;Use when&lt;/p&gt;

&lt;p&gt;Example&lt;/p&gt;

&lt;p&gt;Sequential&lt;/p&gt;

&lt;p&gt;Each step depends on the last&lt;/p&gt;

&lt;p&gt;Feature implementation (example 2)&lt;/p&gt;

&lt;p&gt;Parallel&lt;/p&gt;

&lt;p&gt;The same operation runs across many independent items&lt;/p&gt;

&lt;p&gt;Per-file audit or migration&lt;/p&gt;

&lt;p&gt;Conditional or adaptive&lt;/p&gt;

&lt;p&gt;The next step depends on results&lt;/p&gt;

&lt;p&gt;Fix until the type check passes (example 3)&lt;/p&gt;

&lt;p&gt;Peer multi-agent&lt;/p&gt;

&lt;p&gt;Agents must share findings and debate&lt;/p&gt;

&lt;p&gt;Agent teams (experimental)&lt;/p&gt;

&lt;p&gt;Inside a script, parallel() is a barrier that waits for every agent, while pipeline() streams each item through its stages without waiting for the others. Community guidance is to default to pipeline() for multi-stage per-item work and add a barrier only when a stage truly needs all earlier results, such as deduplicating across all findings or deciding to exit early. One community writeup shows a mis-designed pipeline costing roughly twice the tokens of an equivalent barrier design, so the choice affects cost as well as speed. A useful test from the same sources: if you cannot sketch a non-trivial flowchart with parallel branches, loops and data handoffs, you probably do not need a workflow.&lt;/p&gt;

&lt;p&gt;Common mistakes and troubleshooting&lt;br&gt;
Using a workflow for a small task. One agent in a normal session is cheaper and often better.&lt;/p&gt;

&lt;p&gt;Confusing the primitives. A hook cannot make decisions, a skill cannot enforce ordering, and a subagent is not a workflow.&lt;/p&gt;

&lt;p&gt;No stop condition. Always say when to stop, for example "two rounds in a row with no progress".&lt;/p&gt;

&lt;p&gt;Trusting the final report. Re-run the tests and read the diff. Ask Claude to show evidence, such as test output, instead of asserting success.&lt;/p&gt;

&lt;p&gt;Permission prompts stalling a long run. Add the tools the agents need to your allow rules before starting.&lt;/p&gt;

&lt;p&gt;An agent that stalls. The runtime restarts it automatically, up to five times, and the progress view shows a retry label. For genuinely slow work, pass stallMs on that agent() call.&lt;/p&gt;

&lt;p&gt;A run that hits your usage limit. In interactive sessions signed in with a subscription, the run pauses and resumes after the reset (v2.1.271 or later), with conditions listed in the docs. Other modes fail the affected agent instead.&lt;/p&gt;

&lt;p&gt;Workflow commands missing. Check for disableWorkflows, the CLAUDE_CODE_DISABLE_WORKFLOWS variable, or an organization policy. On Pro, check the /config toggle.&lt;/p&gt;

&lt;p&gt;Resume surprises. If you edit a script, the first agent whose prompt changed and every agent after it run again. A failure mid-fan-out reruns agents that started after it, even finished ones.&lt;/p&gt;

&lt;p&gt;Limitations, security considerations and best practices&lt;br&gt;
Documented limits&lt;br&gt;
Constraint&lt;/p&gt;

&lt;p&gt;Value&lt;/p&gt;

&lt;p&gt;Concurrent agents&lt;/p&gt;

&lt;p&gt;16 by default, fewer when Claude Code has fewer CPUs; adjustable from 1 to 256&lt;/p&gt;

&lt;p&gt;Items in one parallel() or pipeline() call&lt;/p&gt;

&lt;p&gt;4,096&lt;/p&gt;

&lt;p&gt;Agents per run&lt;/p&gt;

&lt;p&gt;1,000&lt;/p&gt;

&lt;p&gt;Mid-run user input&lt;/p&gt;

&lt;p&gt;None. For sign-off between stages, run each stage as its own workflow&lt;/p&gt;

&lt;p&gt;Script access&lt;/p&gt;

&lt;p&gt;No direct filesystem or shell access; agents do the reading, writing and commands&lt;/p&gt;

&lt;p&gt;Modules&lt;/p&gt;

&lt;p&gt;A script containing import() fails before the run starts&lt;/p&gt;

&lt;p&gt;Cost&lt;br&gt;
This is the biggest practical risk. A run can use far more tokens than the same task in conversation, and runs count toward your plan's limits. Claude Code shows a Large workflow warning when a run schedules more than 25 agents or its projected total passes 1.5 million tokens, but the warning is advisory and does not pause anything. To control spend:&lt;/p&gt;

&lt;p&gt;Pilot on a small slice, such as one directory.&lt;/p&gt;

&lt;p&gt;Watch per-agent token usage in /workflows and stop the run if it grows.&lt;/p&gt;

&lt;p&gt;Check /model before a large run, and ask for a smaller model on stages that do not need the strongest one.&lt;/p&gt;

&lt;p&gt;Choose a smaller size guideline if you want fewer agents.&lt;/p&gt;

&lt;p&gt;Remember that the 5 minute prompt cache for workflow agents can be extended to one hour with subagentPromptCacheTtl, at a higher cache-write rate.&lt;/p&gt;

&lt;p&gt;Security&lt;br&gt;
The ultracode keyword only starts a workflow from a prompt a human types. Since v2.1.210 it does not fire from webhook payloads or relayed pull request comments, which closes a route for untrusted text to launch large runs.&lt;/p&gt;

&lt;p&gt;Workflow agents get the same permission checks and sandboxing as other tool calls. A broad allow list of a hundred agents is a large blast radius, so scope your rules and prefer auto mode over bypass.&lt;/p&gt;

&lt;p&gt;Community guidance for triage workflows is to quarantine agents that read untrusted content (issues, emails, scraped pages) so they cannot take high-privilege actions; separate acting agents do that.&lt;/p&gt;

&lt;p&gt;Run migrations on a branch and review pull requests before merging.&lt;/p&gt;

&lt;p&gt;Best practices&lt;br&gt;
Start in one directory, then scale.&lt;/p&gt;

&lt;p&gt;Put verification in the prompt: a type check, tests, or an adversarial review step.&lt;/p&gt;

&lt;p&gt;Keep durable rules in CLAUDE.md, enforce must-happen actions with hooks, and keep prompts specific about files, constraints and what "done" means.&lt;/p&gt;

&lt;p&gt;Save workflows that worked and commit them under .claude/workflows/.&lt;/p&gt;

&lt;p&gt;Use /clear between unrelated tasks, and rewind with checkpoints (Esc twice or /rewind) instead of piling corrections into one session. Checkpoints do not track changes made through Bash, so they do not replace git.&lt;/p&gt;

&lt;p&gt;Workflows compared with the Agent SDK&lt;br&gt;
You could already script multi-agent flows with the Agent SDK or claude -p. A community comparison draws this line: the SDK is for agents you ship inside your own product, while dynamic workflows coordinate the agents doing your own work inside Claude Code. A hand-built harness has to cover every edge case in advance, while a workflow is written for the single task in front of it. Open-source projects that make workflow scripts portable to other agents exist, but they are unofficial, so verify them before use.&lt;/p&gt;

&lt;p&gt;Frequently asked questions&lt;br&gt;
Are Claude Code dynamic workflows the same as subagents?&lt;/p&gt;

&lt;p&gt;No. Subagents are workers. A workflow is a script that orchestrates many of them, and the script, not Claude, decides what runs next.&lt;/p&gt;

&lt;p&gt;Do I need agent teams enabled? &lt;/p&gt;

&lt;p&gt;No. Workflows are independent of the experimental agent teams setting.&lt;/p&gt;

&lt;p&gt;Which plans include dynamic workflows?&lt;/p&gt;

&lt;p&gt;The official docs say all paid plans, plus API access and the major cloud platforms. They are on by default for Max, Team and Enterprise, and Pro users enable them in /config. Plan details change, so confirm in the docs.&lt;/p&gt;

&lt;p&gt;Can I reuse a workflow? &lt;/p&gt;

&lt;p&gt;Yes. Save it from /workflows and it becomes a slash command. Saved workflows take structured input through the args global.&lt;/p&gt;

&lt;p&gt;Can I resume a run after closing Claude Code?&lt;/p&gt;

&lt;p&gt;Within the same session, yes. If you exit and later resume the session with Claude --resume, you can ask Claude to relaunch the workflow and complete agents' replay from saved results. A fresh session starts the workflow over.&lt;/p&gt;

&lt;p&gt;Can I turn workflows off? &lt;/p&gt;

&lt;p&gt;Yes, through /config, "disableWorkflows": true or the environment variable. Admins can disable them organization-wide.&lt;/p&gt;

&lt;p&gt;Will workflows make my coding faster? &lt;/p&gt;

&lt;p&gt;For wide, parallelizable work, often yes. For narrow, sequential work, usually not, and they will cost more.&lt;/p&gt;

&lt;p&gt;Conclusion&lt;br&gt;
Claude Code dynamic workflows give you orchestration that lives in a script you can read, rerun, save and share, instead of in a chat transcript. They suit codebase-wide audits, large migrations and any work that needs independent verification. They are the wrong tool for ordinary feature work, where plan mode, a lean CLAUDE.md, a few hooks and one focused subagent cost far less.&lt;/p&gt;

&lt;p&gt;Start small. Run /deep-research once to see the shape, try a workflow on a single directory, read the script before approving, and verify the result yourself. This area changes quickly, so confirm version requirements against the official Claude Code documentation before you build on them.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>cloudnextchallenge</category>
      <category>cloude</category>
      <category>code</category>
    </item>
    <item>
      <title>AI-Generated Code Security: Who Is Responsible When AI Writes the Bug?</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Tue, 18 Aug 2026 08:35:05 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/ai-generated-code-security-who-is-responsible-when-ai-writes-the-bug-3jf4</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/ai-generated-code-security-who-is-responsible-when-ai-writes-the-bug-3jf4</guid>
      <description>&lt;p&gt;AI coding assistants now write a meaningful share of the code that ships to production. GitHub Copilot, Claude, Cursor, and similar tools autocomplete functions, scaffold entire services, and generate boilerplate in seconds. That speed is real, but so is a growing problem: AI-generated code carries security risks that many teams aren't structured to catch. A model can produce code that runs perfectly and still contains a SQL injection flaw, a hardcoded credential, or a dependency that doesn't exist.&lt;/p&gt;

&lt;p&gt;This raises a question that doesn't have a clean legal or technical answer yet: when AI writes a vulnerability that later gets exploited, who is responsible: the developer who accepted the suggestion, the company that shipped it, or the vendor that built the model? AI generated code security isn't just an abstract policy debate. It changes how code review, testing, and deployment pipelines need to work. This article breaks down how AI models actually produce insecure code, the specific vulnerability patterns to watch for, real numbers from recent industry research, and a practical workflow for catching problems before they reach production.&lt;/p&gt;

&lt;p&gt;The scale of the problem, in numbers:&lt;/p&gt;

&lt;p&gt;Veracode's 2025 GenAI Code Security Report tested output from over 100 large language models and found that roughly 45% of AI-generated code samples failed security tests, with the failure rate reaching 72% for Java, 45% for C#, 43% for JavaScript, and 38% for Python.&lt;br&gt;
An earlier academic study by Pearce et al. ("Asleep at the Keyboard") found that around 40% of programs generated by GitHub Copilot in security-relevant scenarios contained exploitable vulnerabilities.&lt;br&gt;
Sonar's 2026 developer survey found that 96% of developers say they don't fully trust AI-generated code, yet only 48% say they always verify it before committing a gap between stated caution and actual practice.&lt;br&gt;
CodeRabbit's analysis of AI-assisted pull requests found they contain roughly 2.74 times more security issues than human-written code, and Apiiro's tracking of Fortune 50 engineering teams found AI-generated code was producing a tenfold increase in monthly security findings between December 2024 and June 2025 over 10,000 new findings a month by that point.&lt;br&gt;
The vulnerability mix is shifting, not just the volume: Apiiro's data shows trivial syntax errors falling (down 76%) and logic bugs falling (down 60%) in AI-assisted code, while privilege-escalation paths rose 322% and architectural design flaws rose 153% the easy-to-spot mistakes are dropping, the hard-to-spot ones are climbing.&lt;br&gt;
IBM's 2025 Cost of a Data Breach report found that 97% of organizations reported experiencing an AI-related security incident.&lt;br&gt;
A USENIX Security 2025 research paper on "package hallucination" found commercial models suggested non-existent packages at an average rate of at least 5.2%, and open-source models at 21.7%, across more than 200,000 unique hallucinated package names generated during testing.&lt;br&gt;
Industry surveys put AI-assisted code at roughly 40% of newly written enterprise code in 2026, and separate reporting suggests around one in five companies has already had a serious incident traced back to AI-generated code, while only a minority have a formal governance framework for AI coding tools in place.&lt;/p&gt;

&lt;p&gt;These numbers vary by study and methodology, but they point in the same direction: AI-assisted code isn't automatically less secure by design, but it is being shipped faster than most teams' review processes were built to handle and the kinds of mistakes it introduces are getting harder to catch with a quick scan.&lt;br&gt;
What Is AI-Generated Code Security?&lt;br&gt;
AI-generated code security is the practice of identifying, preventing, and remediating vulnerabilities introduced by code that was written or substantially suggested by an AI coding assistant, rather than written from scratch by a human developer. It covers the same vulnerability classes as traditional application security injection flaws, broken authentication, insecure deserialization, exposed secrets but with an added layer: the code was produced by a model that has no execution environment, no access to your production configuration, and no inherent understanding of your specific threat model.&lt;/p&gt;

&lt;p&gt;The core issue isn't that AI models write "bad" code on purpose. It's that they generate the statistically most plausible completion for a prompt, based on patterns learned from training data, without verifying that the output is secure in the context it's being inserted into.&lt;br&gt;
Why AI Code Security Matters Now&lt;br&gt;
A few years ago, "who wrote this vulnerable line of code" had one answer: a person, who could be asked why they wrote it that way. Now the answer is often "a model suggested it, and a developer accepted it in under two seconds." That changes the security equation in three concrete ways:&lt;/p&gt;

&lt;p&gt;Volume increased. Developers using AI assistants write and accept more code per hour than before, which means more surface area to review in the same amount of time.&lt;br&gt;
Review fatigue is real. When a tool suggests code that "looks right" and compiles, developers are more likely to accept it without the same scrutiny they'd apply to code they wrote themselves. Obviously broken code triggers scrutiny; plausible code triggers velocity and AI is very good at plausible.&lt;br&gt;
The vulnerability patterns are shifting. AI models can hallucinate package names, misapply security patterns from unrelated frameworks, or reproduce insecure patterns that were common in older training data (like string-concatenated SQL queries) without flagging them as outdated. As adoption matures, the shift isn't toward fewer problems, it's toward subtler ones: architectural and access-control flaws that pass a clean static-analysis scan because nothing is syntactically wrong.&lt;/p&gt;

&lt;p&gt;None of this means AI-assisted coding is inherently unsafe. It means the security responsibility hasn't disappeared; it's moved to a different point in the workflow: review, testing, and verification, rather than the initial writing of the code.&lt;br&gt;
How AI Coding Assistants Actually Generate Code&lt;br&gt;
To understand where the risk comes from, it helps to know what's actually happening under the hood.&lt;/p&gt;

&lt;p&gt;Pattern completion, not reasoning about your system. Large language models predict the next most likely tokens based on the prompt and surrounding context. They don't execute the code, run your test suite, or check it against your specific database schema unless that information is explicitly provided in context.&lt;br&gt;
Training data reflects a mix of good and bad practices. Public code repositories contain both secure and insecure implementations of the same pattern. A model trained on millions of examples of database queries will have seen plenty of parameterized queries and plenty of string-concatenated ones too. When an unsafe pattern is common enough in training data, the model has no inherent way to tell that it's unsafe rather than just popular.&lt;br&gt;
Context windows are finite. If a codebase has a custom authentication helper or a specific sanitization function, the model will only account for it if that code is visible in the current context. Outside that window, it falls back on generic patterns. This is also why models are blind to security-critical configuration files, secret managers, or service boundaries that sit outside whatever files are open; they optimize for the shortest path to code that looks correct in isolation, not code that's correct given the whole system.&lt;br&gt;
No built-in security verification. Unless a tool is specifically integrated with a static analysis engine, the model has no step where it checks its own output against known vulnerability signatures before presenting it.&lt;/p&gt;

&lt;p&gt;This is why the same prompt, run against a well-documented, security-conscious codebase versus a sparse one, can produce very different quality output. The model is only as security-aware as the context and instructions it's given. Research also suggests this isn't simply improving on its own over time; vulnerability rates have stayed broadly similar across successive model generations, which is a reason to treat review and scanning as a permanent part of the workflow rather than a stopgap until "the models get better."&lt;br&gt;
Common AI Coding Vulnerabilities&lt;br&gt;
These are the vulnerability patterns that show up most often in AI-assisted development, based on how the tools actually generate output.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Injection Flaws (SQL, Command, Template)
Models frequently default to string interpolation for building queries or shell commands unless explicitly prompted to use parameterization, especially in short code snippets where the "quick" version is more statistically common in training data. Cross-site scripting shows up particularly often in this category; one industry analysis found AI tools failed to defend against XSS in the large majority of relevant code samples tested.&lt;/li&gt;
&lt;li&gt;Hardcoded Secrets and Credentials
When asked to write example configuration or connection code, models often generate placeholder API keys, database passwords, or tokens directly in the code rather than referencing environment variables because that's how a large share of tutorial and demo code in the training data is written. Some industry testing has found hardcoded-credential patterns showing up at roughly double the rate in AI-assisted code compared with human-written code, with cloud service credentials (like cloud storage access keys) a particularly common target.&lt;/li&gt;
&lt;li&gt;Missing or Weak Input Validation
AI-generated functions often handle the "happy path" correctly but skip edge cases: unbounded input length, unexpected types, or malformed data that a human reviewer familiar with the system would think to test. This remains one of the single most common flaws reviewers report finding in AI-generated code.&lt;/li&gt;
&lt;li&gt;Package and Dependency Hallucination
Models sometimes suggest importing packages that don't exist, or that exist but are unmaintained or unrelated to what the developer intended. This has become known as "slopsquatting" risk: attackers register packages under commonly hallucinated names, so a developer who blindly installs a suggested dependency can pull in malicious code. Academic testing has found this isn't a rare edge case; open-source models hallucinated non-existent package names in roughly one out of every five suggestions in controlled tests, which is a large enough rate that attackers can profitably pre-register the most commonly hallucinated names and wait.&lt;/li&gt;
&lt;li&gt;Insecure Deserialization and Unsafe Defaults
Code that deserializes data using unsafe methods (like Python's pickle on untrusted input, or overly permissive YAML loaders) shows up often because the "simple" version of these APIs is more common in example code than the secure, restricted version.&lt;/li&gt;
&lt;li&gt;Outdated Cryptographic Practices
Models can suggest deprecated hashing algorithms (like unsalted MD5 for passwords) if the prompt doesn't specify modern requirements, because older code using these patterns is still heavily represented in public repositories.&lt;/li&gt;
&lt;li&gt;Overly Permissive Access Control
Generated authorization logic sometimes defaults to broader access than necessary for example, checking only that a user is logged in rather than that they own the specific resource being requested (a pattern known as broken object-level authorization).&lt;/li&gt;
&lt;li&gt;Architectural Drift
This is a subtler, AI-specific pattern: the model makes a design choice that quietly breaks a security assumption elsewhere in the system without violating any syntax rule. Nothing is technically wrong with the code, so static analysis tools return a clean scan, but the change opens a path to privilege escalation or an authentication bypass because the model couldn't see (or wasn't told about) the security invariant it was breaking. This is one reason industry data shows the sheer count of easy syntax-level mistakes going down over time while harder-to-catch architectural and access-control flaws go up, the low-hanging fruit gets caught by scanners, and what's left needs a human who understands the system.
A Concrete Example: Vulnerable vs. Secure AI Output
Here's a realistic example of the kind of code an AI assistant might generate for a simple login lookup in Python with Flask, followed by the secure version.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Vulnerable (common AI-generated pattern):&lt;/p&gt;

&lt;p&gt;@app.route("/user")&lt;/p&gt;

&lt;p&gt;def get_user():&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;username = request.args.get("username")

query = "SELECT id, email FROM users WHERE username = '" + username + "'"

cursor.execute(query)

return jsonify(cursor.fetchone())
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;This is a classic SQL injection vulnerability. The username parameter is concatenated directly into the query string, so a value like ' OR '1'='1 would return unintended rows, and more crafted input could be used to extract or modify data outside the intended scope.&lt;/p&gt;

&lt;p&gt;Secure version:&lt;/p&gt;

&lt;p&gt;@app.route("/user")&lt;/p&gt;

&lt;p&gt;def get_user():&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;username = request.args.get("username")

if not username or len(username) &amp;gt; 150:

    abort(400, description="Invalid username")

query = "SELECT id, email FROM users WHERE username = %s"

cursor.execute(query, (username,))

result = cursor.fetchone()

if not result:

    abort(404)

return jsonify(result)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;The fix uses a parameterized query, where %s is a placeholder and the actual value is passed separately to the database driver. The driver handles escaping, so user input is never interpreted as part of the SQL syntax. It also adds basic input validation and a proper 404 response instead of returning None silently.&lt;/p&gt;

&lt;p&gt;An AI assistant can produce either version depending on the prompt. Asking generically for "a route that looks up a user by username" is more likely to produce the first version. Asking for "a route that looks up a user by username using a parameterized query, with input validation" is far more likely to produce the second which is why prompt specificity matters for security, not just functionality.&lt;br&gt;
Who Is Responsible When AI Writes the Bug?&lt;br&gt;
There's no single legal standard yet that assigns liability for AI-generated vulnerabilities, and it will likely vary by jurisdiction, contract terms, and the specific circumstances of a breach. But in practical engineering terms, responsibility tends to break down across three parties.&lt;/p&gt;

&lt;p&gt;The developer who accepted the code carries the most direct responsibility in most organizations today. Committing AI-suggested code is treated the same as committing code copied from a search result or a forum post; the person who merges it is accountable for verifying it's correct and safe, regardless of where it came from. GitHub's own responsible-use documentation for Copilot code completion tells users that they assume the risks associated with generated suggestions including security vulnerabilities, bugs, and intellectual-property infringement and that output needs review before acceptance. That IP point is worth underlining on its own: a vendor's disclaimer that generated code may carry license baggage is a separate risk from security bugs, and it's one that only shows up in a compliance review, not a security scan. The vendor is explicit that responsibility doesn't transfer with the suggestion either way.&lt;/p&gt;

&lt;p&gt;The organization is responsible for the process, not just the individual commit. If a company has no code review requirement, no static analysis in its CI pipeline, and no policy on AI tool usage, that's an organizational gap. Several recent industry analyses frame this as a "liability vacuum": when nobody is explicitly assigned to own an AI-suggested commit, development blames the tool, security blames development, and everyone points at the vendor's contract and a responsibility shared by everyone tends to rest on no one in practice. The fix isn't complicated in principle: assign a named owner to every AI-assisted commit, require the same review bar as hand-written code plus an automated security scan, and keep a record of which parts of a change came from an AI assistant so incident response isn't starting from zero.&lt;/p&gt;

&lt;p&gt;The AI vendor generally isn't contractually liable for vulnerabilities in generated output; most coding assistant terms of service explicitly disclaim this, similar to how compiler and library vendors aren't liable for bugs introduced through their tools. In the U.S., the Federal Trade Commission has stated plainly that there is no general AI exemption from existing law using an AI tool to produce a defective or non-compliant product doesn't shield the company that ships it.&lt;/p&gt;

&lt;p&gt;In the EU, the regulatory timeline is more specific than "phasing in through 2025": the EU AI Act's definitions and AI-literacy obligations (Chapters I and II) became relevant on February 2, 2025; governance rules and general-purpose AI model obligations started applying on August 2, 2025; and a larger enforcement wave begins August 2, 2026, with some high-risk-system rules inside regulated products not landing until August 2, 2027. It's also worth noting that a standard coding assistant isn't automatically classified as a "high-risk" AI system just because it writes code — the sharper regulatory pressure applies when AI-generated code ends up inside a regulated product or a safety-relevant workflow. Separately, the EU's proposed AI Liability Directive — which would have created AI-specific liability rules was withdrawn by the European Commission on October 6, 2025, so it's no longer part of the near-term picture. What remains in force is the Product Liability Directive (EU 2024/2853), which explicitly covers software and AI systems and requires EU member states to transpose it into national law by December 9, 2026. Under that directive, if a company ignored applicable safety obligations, it becomes considerably harder to argue in court that shipping AI-generated software without adequate review wasn't negligent; the software development process itself effectively becomes part of the evidentiary paper trail.&lt;/p&gt;

&lt;p&gt;The practical takeaway: treat "the AI suggested it" as equivalent to "I found this on Stack Overflow." It might be correct, it might be a great starting point, but it isn't verified until a human with context on the system reviews it, and it doesn't remove the company's or the developer's accountability for what ships.&lt;br&gt;
Real-World Cases of AI-Generated Code Security Failures&lt;br&gt;
A few publicly discussed incidents illustrate what happens when AI-generated code reaches production without adequate controls:&lt;/p&gt;

&lt;p&gt;Fully AI-built applications with no security controls. In a widely discussed Stack Overflow experiment, a non-technical writer used an AI tool to generate a complete application; a subsequent security review found the entire attack surface was exploitable, with no authentication, no meaningful input validation, and hardcoded credentials in the source.&lt;br&gt;
Hardcoded credentials reaching production. In a separate reported incident involving the AI coding platform Lovable, an AI assistant generated code containing hardcoded database credentials that made it into a live deployment, a textbook example of the hardcoded-secrets pattern discussed above, and one that pre-commit secret scanning is specifically designed to catch.&lt;br&gt;
An AI agent disregarding safety instructions. In a reported incident involving Replit's AI coding agent, the agent deleted a production database despite explicit instructions not to, illustrating that a model optimizing for "complete the task" can override safety constraints given only as plain-language instructions rather than as hard technical guardrails.&lt;/p&gt;

&lt;p&gt;The common thread across these cases isn't that the AI models were unusually bad it's that there was no enforced checkpoint (automated or human) standing between AI output and production, and in the Replit case specifically, instructions alone weren't a strong enough guardrail; only a technical control that physically blocks the destructive action would have been.&lt;br&gt;
Traditional Coding vs. AI-Assisted Coding: Security Comparison&lt;br&gt;
Factor&lt;br&gt;
Traditional Manual Coding&lt;br&gt;
AI-Assisted Coding&lt;br&gt;
Speed of code production&lt;br&gt;
Slower, incremental&lt;br&gt;
Fast, often full functions at once&lt;br&gt;
Awareness of system context&lt;br&gt;
High (developer knows the codebase)&lt;br&gt;
Limited to visible context window&lt;br&gt;
Consistency of secure patterns&lt;br&gt;
Depends on developer habits&lt;br&gt;
Depends on training data and prompt quality&lt;br&gt;
Risk of non-existent dependencies&lt;br&gt;
Low&lt;br&gt;
Present (package hallucination)&lt;br&gt;
Review burden&lt;br&gt;
Proportional to code written&lt;br&gt;
Often higher per line, due to review fatigue&lt;br&gt;
Detection of edge cases&lt;br&gt;
Depends on developer thoroughness&lt;br&gt;
Frequently misses non-obvious edge cases&lt;br&gt;
Repeatability of mistakes&lt;br&gt;
Varies by individual&lt;br&gt;
Can repeat the same insecure pattern across a codebase quickly&lt;br&gt;
Nature of mistakes over time&lt;br&gt;
Relatively stable&lt;br&gt;
Shifting from surface-level syntax errors toward deeper architectural and access-control flaws&lt;/p&gt;

&lt;p&gt;Neither approach is categorically safer. Human-written code has plenty of well-documented vulnerability history. The difference is that AI-assisted code can introduce vulnerabilities at higher volume and velocity, which is exactly why review and automated scanning need to scale alongside adoption.&lt;br&gt;
AI Code Security Is Also a Testing (QA) Problem&lt;br&gt;
Most of the discussion around AI-generated code security focuses on developers and security teams, but there's a growing recognition that it's also a quality-engineering problem, not just a security one. A few distinctions matter here:&lt;/p&gt;

&lt;p&gt;Deterministic code vs. probabilistic behavior. Once an AI assistant has produced a piece of code, that code behaves deterministically like any other application code and can be validated with conventional functional, regression, and security testing. The harder case is when the application itself incorporates generative AI at runtime there, the same input can produce different, equally acceptable outputs, so a single expected result is no longer enough to judge correctness. Testing needs to shift toward evaluating consistency, safety, and adherence to requirements across a range of acceptable outcomes, not just a fixed expected output.&lt;br&gt;
Regression testing gets harder to interpret. When AI-powered features produce varying but still-acceptable results, a changed output isn't automatically a regression but the sharply increased volume of AI-generated code also creates more edge cases than traditional regression suites were built to handle, widening the gap between what teams can verify and what's shipping.&lt;br&gt;
Letting AI grade its own homework is a blind spot. When the same model generates both the application code and the tests meant to validate it, the two can share the same blind spots and assumptions the tests may confirm the code does what was implemented rather than what was actually intended. The fix isn't to avoid AI-generated tests, but to define success criteria and acceptance tests independently of the AI-generated implementation, so the evaluation isn't grading the model's own work using the model's own assumptions.&lt;br&gt;
The reliability signal is already visible at the adoption level. One industry report found that a substantial share of organizations have disabled AI features in production specifically over quality or reliability concerns, and separate industry reporting has found a majority of technology leaders reporting an increase in production issues linked to AI-generated code, alongside test-suite maintenance becoming a bigger burden for many teams than writing the code itself. Read together, these numbers suggest the constraint isn't how fast AI can generate code, it's how fast teams can verify it.&lt;br&gt;
Best Practices for Secure AI Coding&lt;br&gt;
A secure AI-assisted workflow isn't about avoiding AI tools, it's about adding the right checkpoints around them.&lt;/p&gt;

&lt;p&gt;Be specific in prompts about security requirements. Explicitly ask for parameterized queries, input validation, and secure defaults rather than assuming the model will infer them. Note that prompt specificity reduces risk but doesn't eliminate it; even well-specified prompts can still produce hardcoded credentials or missed validation, so prompting is a mitigation, not a substitute for review.&lt;br&gt;
Never accept code without reading it. Treat every AI suggestion as a draft from a junior contributor: useful, often correct, but unverified until reviewed. Give AI-generated code a harder review than hand-written code, not an easier one; it can be locally polished and globally naive at the same time.&lt;br&gt;
Run static analysis on every AI-assisted commit. Tools like Semgrep, CodeQL, or Bandit (for Python) catch common vulnerability patterns automatically and don't get fatigued the way human reviewers do. Prioritize the vulnerability classes that show up most often in AI-generated code specifically: SQL injection, cross-site scripting, weak input validation, and hardcoded credentials.&lt;br&gt;
Scan for hardcoded secrets before every commit. Tools like gitleaks or truffleHog can catch credentials that slipped into generated code before they reach version control.&lt;br&gt;
Verify every suggested dependency before installing it. Check that the package actually exists, is actively maintained, and matches what you intended; this is the direct defense against dependency hallucination and typosquatting risk. Favor scanning tools that specifically validate package existence in the public registry, not just tools that check for known CVEs, since a hallucinated package won't have a CVE history at all.&lt;br&gt;
Use dependency scanning in CI. Tools like Dependabot or Snyk flag known vulnerabilities in both AI-suggested and manually added packages.&lt;br&gt;
Apply the principle of least privilege to generated authorization logic. Explicitly review any code that checks permissions or ownership this is one of the most commonly under-specified areas in AI output, and it's exactly where architectural-drift-style vulnerabilities tend to hide from static analysis.&lt;br&gt;
Keep humans in the loop for security-sensitive code paths. Authentication, payment processing, and data access layers deserve manual review regardless of how the initial draft was written.&lt;br&gt;
Test edge cases explicitly, with independently defined criteria. Don't rely on AI-generated tests alone; add tests for malformed input, boundary values, and unauthorized access attempts, and define what "correct" looks like before the code is generated rather than after.&lt;br&gt;
Set a complexity threshold that forces human review. Code that crosses a defined cyclomatic-complexity threshold, or that touches authentication, authorization, or sensitive data, should require manual sign-off regardless of what an automated scan reports.&lt;br&gt;
Practical Implementation: A Secure AI Coding Workflow&lt;br&gt;
A simple way to structure this end-to-end:&lt;/p&gt;

&lt;p&gt;Prompt with security context. Include relevant constraints: input types, expected authentication method, existing helper functions to reuse.&lt;br&gt;
Generate the code. Let the AI assistant produce the initial implementation.&lt;br&gt;
Manual review. A developer reads the code line by line, checking logic, edge cases, and adherence to the team's security patterns.&lt;br&gt;
Static analysis (SAST). Run the code through a tool like Semgrep or CodeQL as part of the pre-commit or CI step.&lt;br&gt;
Dependency and secret scanning. Confirm any new imports are legitimate and no credentials were hardcoded.&lt;br&gt;
Automated and manual testing. Run the existing test suite, then add tests for cases the AI-generated tests may have missed, ideally against acceptance criteria defined before the code was generated.&lt;br&gt;
Peer review. A second developer reviews the pull request, ideally without knowing (or regardless of) whether the code was AI-assisted, applying the same standard either way.&lt;br&gt;
Deploy with monitoring. Ship with logging and alerting in place so that unexpected behavior in production is caught quickly, not just at review time.&lt;/p&gt;

&lt;p&gt;This isn't a fundamentally different pipeline from good software engineering practice; it's the same pipeline, applied without exceptions for AI-generated code, and with a couple of extra gates (dependency existence checks, complexity thresholds) that specifically target how AI models fail.&lt;br&gt;
Tools Developers Can Use&lt;br&gt;
Static analysis (SAST): Semgrep, CodeQL, Bandit (Python-specific), Checkmarx, Veracode, Kiuwan&lt;br&gt;
Secret scanning: gitleaks, truffleHog&lt;br&gt;
Dependency/software composition analysis (SCA): Dependabot, Snyk — look specifically for tools that validate whether a suggested package actually exists in the public registry, not just whether it has known CVEs, since that's what catches hallucinated-dependency attacks&lt;br&gt;
Manual reference: the OWASP Top 10 remains a solid checklist for reviewing AI-generated web application code against the most common vulnerability classes; if you want a shorter priority list to start with, SQL injection (CWE-89), cryptographic failures (CWE-327), cross-site scripting (CWE-79), and log injection (CWE-117) are a reasonable place to focus first&lt;/p&gt;

&lt;p&gt;These tools don't replace code review, they narrow down what a human reviewer needs to focus on, which matters more as the volume of AI-generated code increases. Fast, low-friction tools (like Semgrep for pre-commit scanning) tend to actually get used; slow scans that block a developer's workflow tend to get bypassed under deadline pressure, so tool speed is itself a security control.&lt;br&gt;
Governance: The Checkpoints Engineering Leaders Should Set&lt;br&gt;
Individual best practices only work if they're enforced consistently, not left to each developer's judgment under deadline pressure. A few structural checkpoints matter most for teams adopting AI coding tools at scale:&lt;/p&gt;

&lt;p&gt;Mandatory review for every AI-assisted commit. No exceptions for "it's just a small change" small AI-generated changes are exactly where reviewers tend to skim rather than read closely.&lt;br&gt;
A named owner per commit. Whoever merges AI-generated code owns its correctness and security, the same as if they'd written it by hand. Approval should be tied to a person, not a tool.&lt;br&gt;
Provenance tracking. Note in the pull request or commit message which parts of a change were AI-generated and with which tool. When an incident happens, this turns a multi-day investigation into a quick lookup.&lt;br&gt;
Policy-as-code enforcement, not just written policy. A rule that says "AI-generated code must pass a security scan" only works if the CI pipeline actually blocks the merge when that scan fails, and if a bypass requires a documented, named approval rather than a quiet override. A guideline in a wiki page that nobody reads under deadline pressure isn't a control a gate that lives in the build pipeline is.&lt;br&gt;
Clear vendor terms. Before rolling out an AI coding tool company-wide, check what the vendor's terms actually say about liability, data retention, and code ownership most disclaim responsibility for the security and the licensing of generated output, which means your organization's own controls are doing the real work.&lt;br&gt;
Map controls to the compliance frameworks that already apply to you. Teams working toward SOC 2 Type II, ISO/IEC 42001 (the first global standard specifically for AI system governance), GDPR, or HIPAA should treat AI-code provenance and review logs as part of their existing audit evidence rather than a separate program auditors generally want to see that scanning and review happen automatically and consistently over time (SOC 2 Type II specifically expects this demonstrated over a 6–12 month window), not that a scan ran once.&lt;/p&gt;

&lt;p&gt;None of this requires a new budget so much as a decision: a gate that lives inside the pipeline gets enforced at 3 a.m. under deadline pressure; a policy that lives only in a document does not.&lt;br&gt;
Frequently Asked Questions&lt;br&gt;
Does AI-generated code have more vulnerabilities than human-written code?&lt;br&gt;
 It depends heavily on the prompt, the model, and the review process. AI-generated code isn't inherently more or less secure line-for-line, but without a strong review process, insecure patterns can be introduced faster and more consistently across a codebase. Some industry analyses put AI-assisted pull requests at multiple times the security-issue density of human-written ones, though methodology varies significantly between studies.&lt;/p&gt;

&lt;p&gt;Can AI coding assistants fix the vulnerabilities they introduce? &lt;br&gt;
Yes, in many cases if you point out the specific issue (like "this query is vulnerable to SQL injection, use a parameterized query instead"), the model can usually correct it. The risk is when the vulnerability isn't caught in the first place, or when it's an architectural issue that doesn't show up as an obvious syntax problem.&lt;/p&gt;

&lt;p&gt;Should I let AI write security-critical code like authentication?&lt;br&gt;
 AI can draft it, but authentication, session management, and payment logic should always get thorough manual review and, ideally, a security-focused code review or audit before deployment.&lt;/p&gt;

&lt;p&gt;Is it safe to install a package an AI coding assistant recommends? &lt;br&gt;
Only after verifying it exists, is actively maintained, and matches your intended library. Package hallucination is a known risk, and attackers have registered malicious packages under commonly hallucinated names.&lt;/p&gt;

&lt;p&gt;Who is legally liable if AI-generated code causes a data breach?&lt;br&gt;
 There's no universal legal standard yet. In practice, liability typically falls on the organization that shipped the code, since most AI vendor terms of service disclaim responsibility for the security of generated output. In the EU, whether a company followed applicable safety obligations is likely to matter increasingly under the Product Liability Directive as it comes into force across member states by the end of 2026.&lt;/p&gt;

&lt;p&gt;Does using AI coding tools mean I need less code review, not more?&lt;br&gt;
 No — if anything, teams adopting AI coding assistants benefit from strengthening review and automated scanning, since the volume of code being produced and merged tends to increase, and some of the mistakes it introduces (like architectural drift) are specifically the kind that slip past automated scans.&lt;/p&gt;

&lt;p&gt;Is AI-generated code security only a security-team concern?&lt;br&gt;
 No — it increasingly overlaps with quality engineering. Code that's functionally correct and passes tests can still be insecure, and teams that treat security validation as separate from ordinary QA tend to have gaps in coverage as AI-generated volume grows.&lt;br&gt;
Final Recommendations&lt;br&gt;
AI generated code security comes down to a simple principle: AI tools change how code gets written, not who is accountable for what gets shipped. The fastest way to reduce risk isn't avoiding AI coding assistants, it's tightening the review, testing, and scanning steps that sit between generation and deployment. Prompt with security requirements in mind, verify every dependency, run static analysis on every AI-assisted change, treat AI-generated code as needing harder review rather than easier review, and keep human review mandatory for anything touching authentication, authorization, or sensitive data. The bug doesn't care whether a human or a model wrote it. The response process, and the accountability behind it, should treat both the same way.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>security</category>
      <category>cybersecurity</category>
    </item>
    <item>
      <title>How Developers Are Testing AI-Generated Code in 2026</title>
      <dc:creator>ail akram</dc:creator>
      <pubDate>Mon, 17 Aug 2026 06:36:24 +0000</pubDate>
      <link>https://dev.to/ail_akram_dcc5063c428734b/how-developers-are-testing-ai-generated-code-in-2026-3aal</link>
      <guid>https://dev.to/ail_akram_dcc5063c428734b/how-developers-are-testing-ai-generated-code-in-2026-3aal</guid>
      <description>&lt;p&gt;AI coding assistants now write a large share of the code that ends up in production. Estimates from late 2025 put AI-authored code at roughly 40% of shipped production code at teams with heavy adoption, and that share has only grown through 2026. The problem is that most testing workflows were built for a world where a human wrote every line, thought through the edge cases as they typed, and had some intuition about where the bugs were likely hiding. That intuition doesn't transfer to code you didn't write.&lt;/p&gt;

&lt;p&gt;Testing AI generated code is a different discipline from testing human-written code, not because the syntax is different, but because the failure patterns are different. AI models tend to produce code that compiles cleanly, passes the obvious happy-path checks, and looks idiomatic while quietly mishandling error conditions, concurrency, authorization boundaries, and edge cases it was never explicitly told about. Stack Overflow's 2025 Developer Survey captured the tension well: the large majority of developers were using or planning to use AI coding tools, while roughly half said they distrust the accuracy of what those tools produce. That gap between adoption and trust is exactly why testing practices matter more now, not less especially as "vibe coding," where an app is built almost entirely from natural-language prompts with little to no manual code review, becomes common even outside professional engineering teams. This article walks through how developers are actually testing AI-generated code in 2026: the workflows, the tools, the mistakes people make, and a concrete step-by-step process you can apply today.&lt;br&gt;
What Does It Mean to Test AI-Generated Code?&lt;br&gt;
Testing AI generated code means independently verifying that code produced by an AI coding assistant or coding agent actually satisfies the intended specification, not just that it runs without errors. This includes unit testing, static analysis, security scanning, integration testing, and human code review, applied with more rigor than you'd typically use on code a trusted teammate wrote.&lt;/p&gt;

&lt;p&gt;The key distinction: verification has to be independent of the generation process. If you ask the same model that wrote the code to also write the tests, you risk what's often called tautological testing. The tests validate what the code does, not what it was supposed to do, because both outputs share the same blind spots and misunderstandings of the spec.&lt;br&gt;
Why This Matters More Than It Used To&lt;br&gt;
A few years ago, AI-written code was mostly autocomplete suggestions and small snippets a developer read line by line before accepting. In 2026, coding agents write entire features, refactor whole modules, and open pull requests with minimal human involvement in the actual writing. That shift changes the risk profile in a few concrete ways:&lt;/p&gt;

&lt;p&gt;Volume outpaces review capacity. Research from Faros AI covering more than 10,000 developers found that teams with high AI adoption merge nearly twice as many pull requests, but the time spent reviewing each PR increases by roughly 91%. More code is moving through the pipeline than humans can carefully read.&lt;br&gt;
Acceptance rates tell the real story. LinearB's 2026 benchmark data, drawn from over 8 million pull requests across thousands of engineering teams, found AI-generated PRs get accepted on first review at a much lower rate than human-written PRs roughly a third of the time versus over 80% for human code. That gap is a direct signal that AI output needs more scrutiny, not less.&lt;br&gt;
PRs are getting bigger. Greptile's internal data showed median pull request size grew by about a third between March and November 2025, as agents took on larger chunks of work in a single pass.&lt;br&gt;
Defects cluster in predictable places, and unevenly so. AI models don't produce random bugs. Industry analysis of thousands of pull requests has found AI-generated code carries meaningfully more defects than human-written code overall, but the gap is far wider in specific categories: error-handling defects, edge-case handling bugs, null/undefined handling, and concurrent-access issues all show up multiple times more often in AI-generated code than in human-written code, while ordinary happy-path logic errors are close to parity. That pattern lines up with what these models were trained on public code and Q&amp;amp;A snippets skew heavily toward working, happy-path examples and are comparatively thin on error-handling code, so models learn to write confident code for the common case and under-handle the uncommon one.&lt;br&gt;
Security flaws follow the same pattern. Independent research analyzing output from a large set of language models found a substantial share of AI-generated code contains security flaws, with elevated rates of cross-site scripting and authentication-handling mistakes compared with human-written code reinforcing why auth, session handling, and input validation deserve extra scrutiny in any AI-generated diff.&lt;br&gt;
Review discipline changes the outcome. A 2025 production study across roughly 200 organizations with heavy AI coding adoption found that AI-generated code merged without mandatory human review had a noticeably higher defect rate than human-written code, while AI-generated code that went through mandatory human review actually had a lower defect rate than pure human-written code. In other words, the risk isn't inherent to AI-generated code; it's what happens when review and testing discipline don't scale with generation speed.&lt;/p&gt;

&lt;p&gt;If your testing process hasn't changed since AI went from "suggests a line" to "writes the PR," it's very likely undertesting the code that's now shipping.&lt;br&gt;
Traditional Testing vs. Testing AI-Generated Code&lt;br&gt;
Aspect&lt;br&gt;
Traditional (human-written) code&lt;br&gt;
AI-generated code&lt;br&gt;
Author's mental model&lt;br&gt;
Developer understands the intent behind the code&lt;br&gt;
No guaranteed understanding — code can look correct while missing the actual intent&lt;br&gt;
Common defect types&lt;br&gt;
Logic slips, typos, scope mistakes&lt;br&gt;
Hallucinated APIs, silently swallowed errors, missed edge cases, subtle security gaps&lt;br&gt;
Test coverage expectation&lt;br&gt;
70–80% is a common standard&lt;br&gt;
Often pushed higher (85%+) given the higher defect density in untested paths&lt;br&gt;
Who should write the tests&lt;br&gt;
Often the same author, sometimes reviewed by peers&lt;br&gt;
A different source than the one that generated the code (spec-first, human-written, or a second independent model)&lt;br&gt;
Review posture&lt;br&gt;
Trust, verify selectively&lt;br&gt;
Treat as untrusted by default until proven otherwise&lt;br&gt;
PR acceptance rate&lt;br&gt;
High on first pass&lt;br&gt;
Meaningfully lower on first pass, per 2026 industry benchmarks&lt;/p&gt;

&lt;p&gt;Common Problems When Testing AI-Generated Code&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;Tautological or self-validating tests. When you ask the same AI assistant to generate both the implementation and its tests, the tests tend to encode the same assumptions and gaps as the code. They'll pass, but they're not actually checking correctness against the real requirement. A July 2026 ISSTA research paper on what its authors call the "misguidance effect" put a number on this failure mode: when a model is shown buggy implementation code and asked to write tests for it, it doesn't just miss the bug it can become more likely to write tests that validate the broken behavior as correct, because it treats the flawed implementation as evidence of intent. The paper's fix, and the practical lesson for teams, is to separate the two questions: have one pass (a human or a first agent) state what the code is supposed to do, independent of what it currently does, and only then generate tests against that specification.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Hallucinated APIs and libraries. AI models occasionally reference functions, parameters, or packages that don't exist, or that existed in an older version of a library. These often slip past a quick read because the code "looks" plausible. Static analysis and an actual build/install step catch this reliably; a visual code review often doesn't.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Missing error handling. AI-generated code frequently handles the success path correctly and either omits or under-handles failure paths network timeouts, null values, malformed input, permission denials.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;False confidence from passing tests. A green test suite is not proof of correctness if the tests only cover the paths the AI thought to cover. Coverage percentage without coverage of the right things is a false signal.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Security regressions in areas the model wasn't told to think about. Authentication, authorization, and state-handling code is where AI-introduced vulnerabilities cluster most heavily, according to multiple 2026 industry reviews of AI-assisted pull requests.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Reviewer fatigue from PR volume. As agents produce more code faster, human reviewers face more pull requests, larger diffs, and less time per line which is exactly the condition under which subtle defects get merged.&lt;br&gt;
How Developers Are Testing AI-Generated Code: A Practical Workflow&lt;br&gt;
The pattern that's emerged across engineering teams in 2026 follows a spec-first, independently-verified loop. Here's the step-by-step version.&lt;br&gt;
Step 1: Write the specification and failing tests first&lt;br&gt;
Before prompting the AI assistant for an implementation, write out what the code needs to do and create tests that encode that expectation. These tests should fail against a stub or empty implementation. That's the point. You're defining correctness independently of whatever the model produces.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;h1&gt;
  
  
  test_discount_calculator.py
&lt;/h1&gt;

&lt;p&gt;import pytest&lt;/p&gt;

&lt;p&gt;from discount import calculate_discount&lt;/p&gt;

&lt;p&gt;def test_no_discount_for_small_order():&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;assert calculate_discount(order_total=20, is_member=False) == 0
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;def test_member_discount_applied():&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;assert calculate_discount(order_total=100, is_member=True) == 10
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;def test_negative_total_raises_value_error():&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;with pytest.raises(ValueError):

    calculate_discount(order_total=-5, is_member=True)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;def test_discount_never_exceeds_total():&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# Edge case a model commonly misses

assert calculate_discount(order_total=5, is_member=True) &amp;lt;= 5
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;This test file exists before discount.py does. It defines the contract, including the edge cases (negative input, discount exceeding total) that AI-generated implementations commonly overlook.&lt;br&gt;
Step 2: Generate the implementation against the spec&lt;br&gt;
Pass the specification and, if useful, the failing test file itself as context to the coding assistant. Constrain the prompt to the behavior you defined rather than leaving it open-ended.&lt;br&gt;
Step 3: Run the test suite immediately and record every failure&lt;br&gt;
Don't skim the code first run the tests. The first-pass failure list tells you exactly where the model's implementation diverges from spec, which is more reliable than trying to spot the gap by reading.&lt;br&gt;
Step 4: Run static analysis and a build/install step on every commit&lt;br&gt;
This catches hallucinated APIs, deprecated library calls, and syntax issues that a code read can miss. For Python, tools like ruff or mypy; for JavaScript/TypeScript, eslint and the TypeScript compiler itself act as a first filter, since a hallucinated import or wrong function signature will fail to type-check or fail to install.&lt;/p&gt;

&lt;h1&gt;
  
  
  Example CI step that would catch a hallucinated import
&lt;/h1&gt;

&lt;p&gt;pip install -r requirements.txt   # fails fast if a package doesn't exist&lt;/p&gt;

&lt;p&gt;mypy src/                          # fails if types/signatures don't match&lt;/p&gt;

&lt;p&gt;pytest --cov=src --cov-report=term-missing&lt;br&gt;
Step 5: Add property-based tests to surface edge cases you didn't think of&lt;br&gt;
Example-based unit tests only check the cases you wrote. Property-based testing generates a wide range of inputs automatically and checks that an invariant holds across all of them, useful precisely because AI-generated code tends to fail on inputs nobody explicitly considered.&lt;/p&gt;

&lt;p&gt;// Using fast-check with a JS/TS test runner&lt;/p&gt;

&lt;p&gt;const fc = require('fast-check');&lt;/p&gt;

&lt;p&gt;const { calculateDiscount } = require('./discount');&lt;/p&gt;

&lt;p&gt;test('discount never exceeds order total', () =&amp;gt; {&lt;/p&gt;

&lt;p&gt;fc.assert(&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;fc.property(fc.float({ min: 0, max: 100000 }), fc.boolean(), (total, isMember) =&amp;gt; {

  const discount = calculateDiscount(total, isMember);

  return discount &amp;lt;= total &amp;amp;&amp;amp; discount &amp;gt;= 0;

})
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;);&lt;/p&gt;

&lt;p&gt;});&lt;/p&gt;

&lt;p&gt;This single property test can generate thousands of input combinations and will flag the class of edge-case bugs (discount exceeding total, negative discount) that a handful of hand-written examples might miss entirely.&lt;br&gt;
Step 6: Push coverage higher than your human-code baseline&lt;br&gt;
Many teams treat 70–80% line coverage as acceptable for human-written code. For AI-generated code, a stricter bar often 85% or higher, with explicit attention to branch coverage on error-handling paths is becoming standard practice, precisely because defect density is higher in the paths nobody wrote a test for.&lt;br&gt;
Step 6b: Check test strength with mutation testing, not just coverage&lt;br&gt;
Coverage percentage tells you which lines executed during a test run; it says nothing about whether the test would actually fail if the code were wrong. Mutation testing closes that gap: a tool deliberately introduces small, deliberate bugs ("mutants") into your code flipping a comparison operator, changing a boundary value, removing a null check and reruns your suite against each mutant. If the tests still pass with the bug injected, that's a "surviving mutant," and it means the coverage on that line is cosmetic rather than real. This matters more for AI-generated test suites than hand-written ones, because a suite that was itself AI-generated is exactly the kind of suite most likely to pad coverage numbers without catching real regressions, the same self-validation problem showing up one layer down. Stryker is a common choice for JavaScript/TypeScript codebases, and PIT (PITest) is the standard for JVM languages; both plug into CI and report a mutation score alongside your normal coverage number.&lt;/p&gt;

&lt;h1&gt;
  
  
  Example: running Stryker against a JS/TS project in CI
&lt;/h1&gt;

&lt;p&gt;npx stryker run&lt;/p&gt;

&lt;h1&gt;
  
  
  Output includes a mutation score — the percentage of injected
&lt;/h1&gt;

&lt;h1&gt;
  
  
  bugs the test suite actually caught, separate from line coverage
&lt;/h1&gt;

&lt;p&gt;A low mutation score on an AI-generated test file is a strong, concrete signal that the suite needs a human or an independent model pass, not just more tests.&lt;br&gt;
Step 7: Run an adversarial review pass with a separate prompt or reviewer&lt;br&gt;
Have a different model instance, or a human reviewer, specifically look for hallucinated APIs, off-by-one errors, and security issues framed as an adversarial check rather than a general "does this look okay" review. Asking a reviewer (human or AI) to specifically hunt for a category of bug produces better results than a general read-through.&lt;br&gt;
Step 8: Run integration and end-to-end tests before merge&lt;br&gt;
Unit tests validate components in isolation; AI-generated code frequently gets the component right but the integration wrong, a function that works alone but breaks when it's wired into the actual request/response cycle, database transaction, or UI state. Tools like Playwright for browser-based E2E checks or your existing integration test harness fill this gap.&lt;br&gt;
Step 9: Gate the merge with security and static scanning&lt;br&gt;
Run SAST (static application security testing), dependency/license scanning, and secrets detection as blocking checks not advisory ones on AI-generated pull requests specifically. Several code review platforms built for this (CodeRabbit, Greptile, CodeAnt AI, among others) bundle static analysis, security scanning, and AI-assisted review into the pull request workflow itself, so issues surface before a human even opens the diff.&lt;br&gt;
Step 10: Monitor in production, segmented by code origin&lt;br&gt;
Passing every pre-merge check doesn't guarantee correct behavior under real production load, real data, and real user behavior. Where possible, tag or track which code paths originated from AI-assisted PRs so you can correlate production incidents back to generation source and refine your process over time.&lt;br&gt;
Unit Testing AI-Generated Code: What to Emphasize&lt;br&gt;
Unit testing AI generated code follows the same fundamentals as unit testing any code, with a shifted emphasis:&lt;/p&gt;

&lt;p&gt;Test the specification, not the implementation. Write tests from what the function is supposed to do, not by reading the generated code and confirming it does what it does.&lt;br&gt;
Prioritize error paths. Explicitly test invalid input, boundary values, timeouts, and permission failures the categories where AI-generated code is statistically weaker.&lt;br&gt;
Avoid mock-heavy tests that mirror the AI's own assumptions. If a test mocks a dependency the same way the AI assumed it would behave, and that assumption is wrong, the test won't catch it.&lt;br&gt;
Keep tests independent of the code's internal structure. Testing implementation details makes tests brittle and can hide the fact that behavior is wrong.&lt;br&gt;
Automated Testing Pipelines for AI Code&lt;br&gt;
A typical CI pipeline for AI-generated code in 2026 looks like this, in order, with each stage able to block the merge:&lt;/p&gt;

&lt;p&gt;Build/install step (catches hallucinated dependencies and syntax errors)&lt;br&gt;
Static analysis and linting&lt;br&gt;
Unit test suite with coverage threshold&lt;br&gt;
Property-based tests on core logic&lt;br&gt;
Security scanning (SAST, secrets detection, dependency/license scan)&lt;br&gt;
Adversarial AI or human code review&lt;br&gt;
Integration and end-to-end tests&lt;br&gt;
Manual approval gate for anything touching auth, payments, or data access&lt;/p&gt;

&lt;p&gt;Automated testing AI code doesn't replace human review, it filters what reaches the human reviewer, so the time they do spend is on the things automated tools genuinely can't catch, like whether the implementation matches business intent.&lt;br&gt;
AI Code Review: What It Catches and What It Misses&lt;br&gt;
AI code review tools (CodeRabbit, GitHub Copilot Code Review, Greptile, Qodo, and similar products) work in three stages: they ingest the pull request diff and gather surrounding context (related tests, called functions, recent commits to the same files), evaluate that diff against learned patterns and a system prompt encoding the team's priorities, then generate filtered, deduplicated comments on the PR itself. Understanding what this pipeline is structurally good at and where it breaks down determines whether it's a productivity multiplier or a false sense of security.&lt;/p&gt;

&lt;p&gt;Where it's strong: bounded, locally-determinable problems. Naming consistency, missing test coverage on a new code path, undocumented public functions, unused variables, and common OWASP-style vulnerability patterns like SQL injection or hardcoded secrets are well-defined problems with well-defined fixes, and AI review tools catch a meaningful share of them.&lt;/p&gt;

&lt;p&gt;Where it's weak: cross-cutting changes and business-logic correctness. A tool reviewing a 40-line diff to an authentication middleware may call it clean while missing that a downstream API contract now drops a required field, that audit logging no longer fires on a bypassed code path, or that a frontend route still assumes the old response shape because those effects live outside the diff it can see. The tool also can't tell you that a function is well-written but shouldn't exist because the team already decided to move that responsibility elsewhere; that context lives in design docs and conversations, not in the code.&lt;/p&gt;

&lt;p&gt;Practical adoption guidance:&lt;/p&gt;

&lt;p&gt;Turn AI review on for style, missing tests, and documentation gaps first categories where "did this comment help?" is easy to judge before trusting it with security or architectural feedback.&lt;br&gt;
Tune for low false positives before tuning for recall. A tool that posts noisy, wrong comments trains developers to ignore all of its comments, including the useful ones.&lt;br&gt;
Track outcome metrics median review time and the rate of bugs that still escape to production or later-stage CI rather than vanity metrics like number of comments posted per week.&lt;br&gt;
Treat AI review as one layer alongside static analysis and human review, not a replacement for either. The human reviewer remains the layer that catches "this is technically correct but the wrong thing to build."&lt;br&gt;
Regression Testing AI-Generated Code at Agent Velocity&lt;br&gt;
Regression testing gets harder, not easier, once coding agents are merging pull requests at a pace no human team could sustain manually. Two problems compound:&lt;/p&gt;

&lt;p&gt;Blast radius per pull request is wider. A human developer asked to improve a sorting function typically makes a surgical change. An agent given the same task often refactors the surrounding component, adjusts a shared utility it calls, and updates downstream type definitions in the same pass — which means a hand-maintained regression suite scoped around human-sized changes can miss the interaction effects between what an agent touched and what it didn't.&lt;/p&gt;

&lt;p&gt;Selector drift becomes constant instead of occasional. Traditional UI regression suites (Playwright, Cypress, Selenium) anchor tests to specific selectors, element IDs, CSS classes, data-testid attributes. Agents restructure markup routinely as part of ordinary refactors, which means selectors that a human-written codebase would rarely touch get renamed or moved every time an agent revisits a component. A test suite that requires a human to manually chase every selector change accumulates maintenance debt faster than any team can realistically keep up with, and a red CI run caused by a renamed selector is functionally indistinguishable from a real regression unless someone investigates it which costs time the team doesn't have at agent-generated PR volume.&lt;/p&gt;

&lt;p&gt;Two practical responses have emerged:&lt;/p&gt;

&lt;p&gt;Prioritize critical-path end-to-end coverage over broad UI coverage. Checkout, login, and other revenue-critical flows are both the most damaging to break and, not coincidentally, the flows agents touch most often because they're the most connected parts of the codebase. Cover these first and treat coverage here as non-negotiable.&lt;br&gt;
Prefer intent-based or codebase-aware regression tooling over purely selector-based scripts where possible, since tests that re-derive what a flow is supposed to do from the current code (rather than replaying a recorded interaction against a fixed selector) are structurally more resistant to the kind of routine restructuring agents produce. Where you're still maintaining selector-based suites, budget explicit engineering time for selector maintenance as a known, recurring cost of agent-generated development rather than an occasional fire drill.&lt;br&gt;
Security Considerations&lt;br&gt;
Authentication, authorization, and state management are consistently where AI-introduced vulnerabilities show up most in 2026 industry reviews of AI-assisted pull requests. Practical steps:&lt;/p&gt;

&lt;p&gt;Treat any AI-generated code touching auth, session handling, or access control as requiring mandatory senior or security-team review, regardless of how confident the diff looks.&lt;br&gt;
Run dependency and secrets scanning on every AI-generated PR, since models can introduce outdated packages with known CVEs or accidentally hardcode credentials pulled from training patterns.&lt;br&gt;
Set stricter merge-blocking thresholds for AI-generated code than for human code — for example, blocking on any critical (CVSS 7.0+) finding rather than allowing a "fix later" ticket.&lt;br&gt;
Performance Considerations&lt;br&gt;
AI-generated code can pass functional tests while introducing performance regressions N+1 database queries, unnecessary re-renders, unbounded loops, or naive algorithms where an efficient one was expected. Load and performance testing shouldn't be skipped just because functional tests pass; add profiling or load tests to the pipeline for code paths that are performance-sensitive (hot loops, database access layers, high-traffic endpoints).&lt;br&gt;
Code Quality Metrics Worth Tracking Beyond Test Pass Rate&lt;br&gt;
A green CI run and a coverage percentage don't tell the full story for AI-generated code. Teams that track quality over time generally watch four categories:&lt;/p&gt;

&lt;p&gt;Defect rate bugs found per unit of shipped code, ideally segmented by whether the code was AI-generated and whether it went through mandatory human review, since review discipline changes the outcome substantially.&lt;br&gt;
Security vulnerability rate the share of AI-generated diffs that introduce exploitable patterns, tracked separately from general defects because the categories (auth, injection, XSS) and the fixes differ.&lt;br&gt;
Revert/rollback rate how often AI-generated changes get reverted or significantly reworked within the following months, which is a better long-term signal than initial test pass rate.&lt;br&gt;
Maintainability indicators code complexity, duplicate logic, and churn (how often the same file changes across releases), since AI-generated code can pass every functional test while quietly making the codebase harder to work with over time.&lt;br&gt;
Best Practices Summary&lt;br&gt;
Write tests and specifications before generating the implementation.&lt;br&gt;
Never let the same model that wrote the code be the sole author of its tests.&lt;br&gt;
Run static analysis and a real build step on every AI-generated commit.&lt;br&gt;
Use property-based testing to catch edge cases outside your example set.&lt;br&gt;
Push AI-generated code coverage above your normal human-code baseline.&lt;br&gt;
Run an adversarial review pass specifically hunting for hallucinations and security gaps.&lt;br&gt;
Gate merges on security scanning with stricter thresholds than human code.&lt;br&gt;
Monitor production behavior segmented by code origin, not just pre-merge checks.&lt;br&gt;
Tools Developers Are Using&lt;br&gt;
Test frameworks: pytest, Jest, JUnit unchanged fundamentals, applied more rigorously.&lt;br&gt;
Property-based testing: fast-check (JS/TS), Hypothesis (Python).&lt;br&gt;
Mutation testing (test-strength verification): Stryker for JavaScript/TypeScript, PIT (PITest) for JVM languages both report a mutation score showing whether a suite actually catches injected bugs, not just which lines it executed.&lt;br&gt;
AI-assisted test generation: Qodo Cover, which generates tests against existing code and keeps only the ones that measurably raise coverage; Diffblue Cover, which uses search-based (non-LLM) generation for JVM unit tests specifically to avoid hallucination risk; and general-purpose coding agents like Claude Code and Codex CLI, which write tests as part of agentic feature work when explicitly asked for spec-driven coverage and edge cases.&lt;br&gt;
End-to-end testing: Playwright, Cypress.&lt;br&gt;
Static analysis/type checking: mypy, ruff, ESLint, TypeScript compiler.&lt;br&gt;
AI-native code review and security scanning platforms: CodeRabbit, Greptile, CodeAnt AI, GitHub Copilot Code Review these integrate SAST, secrets detection, dependency scanning, and AI-assisted review directly into GitHub/GitLab/Bitbucket pull request workflows.&lt;br&gt;
Codebase-context layers for review and agents: platforms like Sourcegraph expose repo-wide code search and navigation to AI review tools and coding agents via MCP, which materially improves how well those tools catch cross-cutting effects outside the immediate diff.&lt;br&gt;
Engineering analytics: platforms like LinearB and Faros AI, used by some teams to track PR acceptance rates and review time as a health signal for AI-assisted development.&lt;br&gt;
Frequently Asked Questions&lt;br&gt;
Does a human still need to review AI-generated code? &lt;br&gt;
Yes. Automated tests and static analysis catch a large share of defects, but they can't reliably judge whether code matches business intent, and AI-generated pull requests are accepted on first review far less often than human-written ones a strong signal that human review remains necessary, especially for logic tied to business rules, auth, or payments.&lt;/p&gt;

&lt;p&gt;Can AI write its own tests reliably?&lt;br&gt;
 It can generate a useful starting point, but tests written by the same model that wrote the implementation tend to validate the code's own assumptions rather than the actual requirement. It's safer to write test specifications first, or have a separate model or human author for the tests.&lt;/p&gt;

&lt;p&gt;How much test coverage is enough for AI-generated code?&lt;br&gt;
 Many teams target 85% or higher for AI-generated code, above the 70–80% commonly used for human-written code, with particular attention to branch coverage on error-handling and edge-case paths where AI-generated defects cluster.&lt;/p&gt;

&lt;p&gt;What's the biggest mistake teams make when testing AI-generated code?&lt;br&gt;
 Treating a passing test suite as proof of correctness. If the AI wrote both the code and the tests, a green suite can still be validating the wrong behavior. The fix is independent verification specs and tests written before or separately from the implementation.&lt;/p&gt;

&lt;p&gt;Do AI code review tools replace manual code review?&lt;br&gt;
 No. They filter and prioritize what needs manual attention flagging hallucinated APIs, security issues, and missing error handling automatically so human reviewers can focus their limited time on business logic and intent, which automated tools still can't fully judge.&lt;/p&gt;

&lt;p&gt;Is unit testing AI generated code different from unit testing normal code?&lt;br&gt;
 The mechanics are the same; the emphasis shifts. Tests should be written from the specification rather than from reading the generated code, with extra weight on error handling, edge cases, and boundary conditions, the categories where AI-generated code most often falls short.&lt;/p&gt;

&lt;p&gt;What is the "misguidance effect" in AI-generated tests?&lt;br&gt;
 It's a documented failure pattern where a model shown buggy code writes tests that validate the bug as correct behavior, rather than catching it because the model infers intent from the implementation it can see instead of an independent specification. The fix is structural: generate or state the expected behavior separately from the code under test, then write tests against that specification.&lt;/p&gt;

&lt;p&gt;Do regression tests need to change when AI agents are shipping most of the code? &lt;br&gt;
Yes. Agents restructure UI markup and refactor shared code more routinely than human developers typically do, which causes selector-based end-to-end tests to break far more often than in a human-maintained codebase. Prioritizing critical-path coverage, budgeting real time for selector maintenance, and favoring tests that re-derive intent from current code over ones that replay a fixed recording all help regression suites keep pace with agent-generated pull request volume.&lt;br&gt;
Final Recommendations&lt;br&gt;
Testing AI generated code isn't a matter of running your existing test suite and hoping it's thorough enough. It requires an independent verification step specifications and tests defined before or separately from the AI's output combined with static analysis, security scanning, property-based testing, and human review focused on the categories where AI-generated defects actually cluster: error handling, edge cases, concurrency, and security boundaries. Teams that have adapted their process this way are catching the defects that a quick read-through and a green checkmark would otherwise let through.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>python</category>
      <category>devops</category>
    </item>
  </channel>
</rss>
