Source note
Architecture Without Architects: How AI Coding Agents Shape Software Architecture
AI Coding AgentsSoftware ArchitecturePrompt EngineeringCode GenerationMulti Agent Software Engineering
Summary
This position paper argues that AI coding agents already make software architecture decisions, often without review or recorded rationale. It introduces a model of how prompts drive infrastructure choices and shows, with a small case study, that changing prompt wording alone can produce different system architectures.
Problem
- The paper studies how coding agents choose frameworks, databases, integrations, and decomposition strategies during code generation, even when teams do not treat those choices as architecture decisions.
- This matters because those decisions happen fast, arrive bundled, and often leave no ADRs, design docs, or review trail, which creates governance, security, and maintenance risk.
- The paper also argues that prompt features such as structured output, tool access, and retrieval requirements can force extra infrastructure, so a prompt can act as an architecture specification.
Approach
- The authors identify five mechanisms of agent-driven architectural choice from a survey of coding tools: model selection, task decomposition, default configuration, scaffolding/autonomous generation, and integration protocols.
- They propose six prompt-architecture coupling patterns grouped into constraint, capability, and context patterns: structured output, few-shot selection, function calling, ReAct reasoning, RAG, and context reduction.
- They classify these couplings as contingent when stronger model capabilities may reduce the extra infrastructure, or fundamental when the infrastructure is logically required, such as tool orchestration.
- They run an illustrative case study with three independently generated customer-service chatbot variants using Claude Code with default settings, while keeping the runtime model fixed at GPT-4o-mini and changing only the prompt wording.
- They use the case study to trace how prompt specificity changes components, dependencies, and failure modes, then discuss review practices, ADR generation, and architecture-aware governance tooling.
Results
- The main concrete result is architectural divergence from prompt wording alone on the same task: Variant A (“answer product questions from a FAQ”) produced 141 LoC, 2 files; Variant B (structured JSON with schema validation) produced 472 LoC, 4 files; Variant C (tool access) produced 827 LoC, 6 files.
- Relative to Variant A, the most complex variant grew by about 5.9x in code size (141 → 827 LoC) and 3x in file count (2 → 6 files).
- Structured output added concrete components absent in the simpler prompt: Zod schema, retry handler, fallback generator. Tool access added tool registry, agent loop, SQLite state store.
- The paper claims five agent decision mechanisms and six recurring coupling patterns, but these are analytical contributions, not empirically validated benchmarks.
- There are no quantitative accuracy or benchmark results on datasets, task success, or comparisons against baselines such as human-designed architectures or other agents. The evidence is a tool survey plus a single illustrative case study.