Atelier: Building a Reproducibility Control System for AI-Assisted Software Engineering

Atelier is an intelligent coding workflow framework derived from practical experience in safety-critical HAZOP/LOPA AI systems. It aims to address the traceability, reproducibility, and security issues when AI-assisted programming moves from personal experiments to production deployment. At its core, it transforms 'vibe programming' into production-grade engineering practices through a file-first philosophy, multi-agent debate mechanism, and mandatory human review, with core concepts of Traceable, Replayable, and Reconstructable.

Large language models have driven a productivity revolution in AI coding, but when moving from personal experiments to team collaboration and production deployment, traditional software engineering mechanisms (version control, code review, architecture documentation) face challenges: How to review AI-generated code? How to record AI design decisions? Who is responsible for erroneous code output by AI? These issues hinder the transition of AI coding to production grade.

Atelier is a reproducibility control system specifically designed for AI-assisted software engineering, with core concepts of 'Traceable, Replayable, Reconstructable'. It originated from practical development experience in safety-critical HAZOP/LOPA AI systems—where erroneous outputs could lead to severe consequences—thus abstracting general AI-assisted development workflow disciplines and memory management infrastructure.

Atelier's core mechanisms include:

1. File-First Philosophy: Treat the file system as the only source of truth; Markdown/YAML carry information; Git for audit tracking—ensuring portability, reviewability, and recoverability;
2. Data Packet Engine + Context Compiler: Resolve chaos in AI agent context management; implement priority stratification, deduplication, budget control, and source tracking;
3. Mandatory Review Enforcement: Reviewers must paste real command outputs as evidence; approval without evidence is considered incomplete;
4. Evidence Package: Capture proof of review execution; establish a reproducible decision chain;
5. Typed Memory: Structurally record decisions, review findings, and rejected solutions; automatically generate ADRs and change logs;
6. Multi-Agent Debate: Triggered only in cases of deadlock, complex clarification, or major architectural decisions to avoid resource waste;
7. Human Intervention at Destructive Gates: AI does not automatically resolve merge conflicts or push to the main branch; human authorization is required.

Atelier adopts an LLM-agnostic design, supporting Claude, Codex, Qwen, DeepSeek, and local models, abstracting model features through a capability list. The project structure includes a Python control plane (to be built), preset configurations, demonstration cases, and ADR documents (in MADR3.0 format). This architecture has undergone 7 rounds of critical validation by multiple independent LLM agents and has converged.

Atelier emphasizes: Coding agents do not lack capabilities—they lack workflows, discipline, and memory. Current AI programming tools easily lead to 'vibe programming' (AI freely improvises, generates quickly but lacks discipline), which becomes a breeding ground for technical debt. Atelier provides strict engineering discipline, acknowledging AI capabilities but not blindly trusting their reliability, leveraging efficiency without abandoning human responsibility—it is the key to AI tools moving from toys to production.

Atelier integrates cutting-edge practices from multiple fields: GitHub spec-kit (specification-driven development), MADR3.0 (architecture decision records), Karpathy LLM Council (three-stage integration), Du et al. 2023 multi-agent debate research, SARIF (inspiration for evidence package specifications), and TIROS HAZOP engineering discipline (mandatory review, data integrity, etc.).

Atelier represents a thoughtful response to AI-assisted development—it does not chase the latest model capabilities but focuses on the integration of AI with reliable engineering practices. For teams introducing AI into production processes, it provides a practice-verified framework. Its value lies in making AI code more maintainable, reviewable, and trustworthy, marking a key leap for AI-assisted development from a novel toy to a serious tool.