AI Fully Automated Orchestration in Practice: How Software Production Costs Are Being Completely Disrupted

From "Building Tools" to "Building the Tool That Builds Tools"

A video creator found making videos too complex and wanted to use AI to generate supplementary visuals, so he began developing small tools one by one with Claude Code. But during this process, he realized what he truly needed wasn't individual tools—it was a fully automated software generator. Just input a use case, and the system would automatically produce usable software around the clock through a series of orchestrated workflows.

This idea sounds somewhat outlandish, but he claims to have partially achieved it. What this reflects is that AI is fundamentally reshaping every aspect of software engineering.

Background: The Evolution of Claude Code and AI IDEs Claude Code is a command-line AI programming tool released by Anthropic, representing a paradigm shift in AI programming tools from "code completion" to "autonomous programming Agents." Early GitHub Copilot primarily handled line-level/function-level code completion, and Cursor upgraded this to file-level context-aware editing. Claude Code goes further—it can autonomously read and write files, execute commands, and run tests in the terminal, forming a complete "perceive-decide-execute" loop. This capability makes it an ideal foundational component for building multi-Agent orchestration systems, and is the technical prerequisite that makes the "fully automated software generator" described in this article possible.

AI Is Reshaping Every Aspect of Software Engineering

Traditional software engineering has a mature methodology: write documentation, write code, write tests, deliver and accept. Even in the early days of AI IDEs like Cursor, most people only used them to assist traditional workflows. But now, an entirely new paradigm is emerging.

If you've been deeply using Claude Code for a while

Taking the author's practice as an example, his workflow is now completely different from traditional development:

Only write Use Case scripts — describe usage scenarios in natural language
Continuously amplify details through conversation with AI — gradually transform vague requirements into precise specifications
Generate a set of Specs sufficient to initiate automated programming — this is the starting point for AI to begin working independently
Wait for AI to complete development — during which AI autonomously codes and debugs
Use AI-assisted acceptance — automated testing and quality checks

The core change in this workflow: the human role shifts from "the person who writes code" to "the person who describes requirements and accepts results."

Background: The Methodological Origins of Spec-Driven Development "Spec-oriented programming" is not an entirely new concept. Its intellectual roots trace back to Formal Methods and Behavior-Driven Development (BDD). BDD requires developers to first write "user stories" and "acceptance criteria" in natural language, then drive code implementation from them. Spec-driven development in the AI era automates this workflow: natural language Specs are transformed by LLMs into structured requirements documents, which then drive code generation Agents, with testing Agents finally performing acceptance against the original Specs. Throughout this entire loop, humans only need to maintain the accuracy of Specs—the code itself becomes a "compiled artifact" of the Spec rather than the core asset. This means software's "Source of Truth" migrates from the codebase to the requirements documentation—a fundamental shift at the epistemological level of software engineering.

Orchestration: The Core Capability of the AI Programming Era

The author proposes an extremely insightful concept—Orchestration.

He uses "entropy" as an analogy for the software development process: writing code is an entropy-increasing process (continuously introducing bugs), while testing is an entropy-decreasing process (removing bugs). How to produce fewer bugs and discover them more efficiently—this fundamental question has never changed. Good orchestration is the key to accelerating entropy reduction.

Background: The Technical Meaning of Orchestration The concept of Orchestration originates from microservices architecture and cloud-native domains (such as Kubernetes orchestrating containers), with the core idea being coordination of multiple independent units working together according to predetermined logic. In the AI Agent domain, orchestration specifically refers to how to organize multiple LLM calls, tool calls, and state management into reliable automated pipelines. Hooks mechanisms allow inserting custom logic at specific lifecycle points of Agent execution (such as automatically running lint checks, formatting, or security scans before code commits), while Skills are pre-packaged capability modules that can be reused by different Agents. This is highly similar to traditional CI/CD pipelines, but the execution units change from deterministic functions to probabilistic LLM reasoning, requiring more careful fault-tolerance design and result verification mechanisms.

We introduce another supervisory agent in this process

Specifically, orchestration means:

Each step is executed by a different Agent: From document generation to code writing to test verification, each phase is handled by a specialized Agent
Configuring different Hooks and Skills: In Claude Code, through carefully configured hooks and skills, AI can more reliably complete tasks at each stage
Introducing a supervisory Agent: A dedicated Agent responsible for monitoring and coordination, achieving near-full automation
Generating analyzable logs: Execution results from each step are recorded, with AI used to analyze and optimize the orchestration itself

Even more radical is the author's proposal of a concept that traditional software engineering never had: parallel orchestration. In the past, we always developed from state A to state B sequentially. But in the AI era, we can simultaneously develop from A to B1, B2, B3, and B4, verifying in parallel which orchestration path is optimal.

Background: The Fundamental Difference Between Parallel Orchestration and Traditional Software Engineering Traditional software engineering is constrained by "human labor as a linear resource"—architectural decisions are often sequential: first review Plan A, then discuss Plan B after rejection. This seriality leads to massive "sunk costs"—time consumed by rejected plans cannot be recovered. Parallel orchestration breaks this constraint: AI can simultaneously generate and verify multiple technical paths, with humans only needing to choose among final results rather than participating in every decision. Economically, this is equivalent to transforming "sequential decision-making" into "parallel experimentation," with information acquisition efficiency improving by orders of magnitude. Similar approaches have long been practiced in drug development (high-throughput screening) and chip design (parallel multi-layout simulation). AI programming brings this to software engineering—computing power is labor, something completely unimaginable in the human-labor era.

Cost Disruption: The Milestone Significance of MiniMax M1

Many people might ask: can the costs of this fully automated software production approach be sustained?

The author points out that several key milestone events have recently occurred, making cost no longer a barrier:

What it proves

First, a flood of domestic coding subscription plans. Many companies have launched top-tier coding subscription packages, and it's actually difficult for a single person to hit the usage limits. This means for individual developers, the marginal cost of AI programming has already approached zero.

Second, the release of the MiniMax M1 model. This is a model using a Mixture of Experts (MoE) architecture—with massive total parameters but only activating a small portion during each inference—that has proven capable of handling fully automated software production workflows.

Background: The Technical Architecture Significance of MiniMax M1 MiniMax M1 adopts a Mixture of Experts (MoE) architecture—the core advantage of this architecture is: the model contains numerous "expert networks," but the routing mechanism only activates a few experts during each inference, making actual computation far less than a "Dense Model" of equivalent scale. This makes it possible to run high-performance models on consumer-grade or small commercial GPU clusters. A four-card A100/H100 server costs approximately 600,000-1,000,000 RMB (roughly $80,000-$140,000), which is an acceptable one-time capital investment for small and medium enterprises. Compared to cloud API calls billed per token, local deployment compresses marginal inference costs to near electricity costs—this is the underlying logic behind the author's statement that "GPUs are assets with low depreciation rates."

The author paints a very specific scenario: in the future, every non-software company will only need one product manager plus one programmer, paired with a four-GPU server, to independently develop enterprise-customized software. GPUs are assets with low depreciation rates, and the marginal cost of software production is essentially zero.

This directly disrupts the business model of traditional custom software development. When enterprises can produce software at extremely low cost themselves, the market space for outsourced development and custom development will be dramatically compressed.

How Ordinary People Can Seize the AI Programming Dividend

Facing such transformation, the author offers very pragmatic advice:

To accelerate your own workflow

Core Insight: Demand Won't Disappear—It Will Explode

The reduction in software production costs won't eliminate demand; rather, it will bring massive new demand. Software needs that were previously impossible to realize due to high costs now become feasible. And the people solving these needs don't have to be programmers—anyone who masters AI programming skills can participate. This is consistent with the pattern of every productivity revolution in history: the spread of the printing press didn't eliminate the demand for writing but instead gave birth to the publishing industry; the spread of electricity didn't eliminate handicrafts but instead created the new profession of electrical engineer.

Three Action Items

Start using AI Coding immediately: Buy a top-tier coding plan (such as Claude Code, Cursor Pro), use it intensively for a period, and you will inevitably gain insights
Learn basic software engineering knowledge: You don't need to become a professional developer, but understanding code fundamentals, industry terminology, and conventions will help you collaborate better with AI. Understanding version control (Git), basic data structure concepts, and API call logic is enough to help you write more precise Specs when collaborating with AI and more effectively validate AI's output
Use AI to accelerate your own workflow: Regardless of your industry, try using AI programming to create tools you need

The author also mentions a heartwarming detail: his daughter has been learning C++ and algorithms for several years, and he wants to build a fully automated software generation tool for her, making it easier for her to create interesting things with code. This isn't just technical practice—it's cultivating the next generation's foundational methodology of "solving problems with AI."

Final Thoughts

Many say the coming year will be the "era of Spec-oriented AI programming," but the author believes this perspective is still too narrow. The real transformation isn't just "using AI to write code"—it's using AI to orchestrate the entire software production workflow. From requirements analysis to architecture design, from coding implementation to testing and acceptance, every step is completed through AI Agent collaboration, with humans only needing to define objectives and acceptance criteria.

As inference costs continue to decline and smaller-parameter models prove capable of complex programming tasks, the barriers to software production will be completely shattered. This isn't the future—this is happening right now.

As the author puts it: AI is like a dog constantly chasing you from behind, running faster and faster. You must start running, and you need to run even faster.