How End‑to‑End Delivery 2.0 Turns AI Coding into an Industrial‑Scale Assembly Line

Before 2.0, the AI‑coding pipeline (Spec‑driven since Dec 2025) could generate thousands of lines of code per change, but quality checks, information loss, and model instability caused major bottlenecks. The author observes five concrete pain points: unchecked code quality, high information‑processing cost, unpredictable behavior on complex tasks, expensive top‑model reliance, and fragile local execution.

Why a New Delivery System Is Needed

The core insight is that AI coding’s real limitation is not model capability but the lack of an industrial‑like production system. Like a factory that uses a well‑defined workflow, a software factory must have clear inputs, outputs, quality checkpoints, and continuous feedback.

2.0 End‑to‑End Architecture

The 2.0 system consists of two parallel tracks: (1) Agent‑driven automation that lets non‑developer roles submit requirements via DingTalk, and (2) a new 2.0 specification standard that defines the full lifecycle from PRD to deployment, including Harness constraints, Spec generation, self‑checks, and a continuous‑optimization loop.

Core Agents

Coordinator (architect) Agent : interacts with the user to clarify requirements and creates a structured spec.

Product‑Manager Agent : transforms the clarified need into a spec.md with a unique aone_id.

Backend‑Engineer Agent : writes code according to the spec.

Test Agent : generates and runs test cases.

Code‑Review Agent : performs independent diff audits.

Security/SRE Agent : evaluates compliance and operational impact.

Each agent runs in a sandbox with minimal permissions and records its actions in a session/ log, providing a black‑box for later debugging.

Harness and Spec Engineering

Harness defines four layers of constraints—Principle → Constitution → Rules → Cases—similar to national legislation, ensuring that every agent follows the same standards regardless of the underlying model. Spec describes the production workflow: requirement alignment, technical design ( plan.md), task decomposition ( tasks.md), execution, and multi‑role verification.

specs/{aoneID}_{需求名}/
├── spec.md          # functional specification
├── plan.md          # technical design
├── tasks.md         # batch task list (optional)
├── check_reports/  # self‑check reports (required)
│   ├── check.summary.md
│   └── 00‑main‑chain.md
├── test/            # test case analysis (optional)
└── session/         # full agent conversation log

The Spec system enforces SDD (Spec‑Driven Development) and TDD (Test‑Driven Development) principles, controls batch size to stay within model context windows, and separates design from execution so that any agent can run the same material locally (e.g., in Qoder) or on the cloud platform.

Verification and Continuous Improvement

After code generation, a dedicated R&D Self‑Check Agent runs in an independent session, producing three role‑based reports (product, developer, security/SRE) and a consolidated check_summary.md with PASS, CONDITIONAL_PASS, or FAIL outcomes. The Statistics & Loop Engine scans all artifacts, applies a 4+1 problem‑detection framework, and feeds findings back into Harness rules and Skills, forming a feedback loop that continuously refines the pipeline.

Project‑Level Coordination

For cross‑application changes, a project‑level spec adds a top‑priority constitution, shared API contracts, and a pre‑check that ensures every participating application has complete AI‑coding material. This mirrors a multiplayer raid in a game: a shared strategy (architecture) and coordinated roles (agents) enable large‑scale, multi‑service delivery.

Material Generation & Evolution

New applications can adopt material via two modes: (1) Clone mode copies mature material from a similar service and adapts it locally; (2) Scan‑and‑generate mode lets an agent analyze existing code to produce fresh Harness and Spec assets. After installation, a “hot‑car” run on simple demands validates the material before scaling up.

Knowledge Base

A two‑tier knowledge base (local refined .md files and a remote kbase) supplies domain‑specific concepts, data models, and historical pitfalls, ensuring agents have both generic AI skills and product‑specific expertise.

Conclusion

The 2.0 framework shifts AI coding from a fragile, model‑centric tool to a robust, industrial‑style delivery system. By separating constraints (Harness), process (Spec), verification (self‑check), and continuous optimization (Statistics & Loop), the approach promises scalable, traceable, and cost‑controlled software production. Future work will dive deeper into PRD generation, autonomous testing, and long‑running autonomous generation.