Context Before Code: An Experience Report on Vibe Coding in Practice

• URL: http://arxiv.org/abs/2603.11073v1
• Date: Tue, 10 Mar 2026 20:20:33 GMT
• Title: Context Before Code: An Experience Report on Vibe Coding in Practice
• Abstract summary: This paper presents an experience report on "vibe coding" under production constraints.<n>We build a multi-project agent learning platform designed for sustained, production-oriented use.<n>We identify recurring architectural "non-delegation zones" where conversational code generation remains insufficient for production reliability.
• Score: 1.7327102304628392
• License: http://creativecommons.org/licenses/by/4.0/
• Abstract: Code-generating tools are increasingly used in software development, yet experience reports on conversational "vibe coding" under production constraints remain limited. This paper presents an experience report from a small full-stack team that applied contextual prompting and explicit architectural constraints to build (i) a multi-project agent learning platform designed for sustained, production-oriented use and (ii) an academic retrieval-augmented generation system. The agent platform supports multiple isolated projects, each with structured memory and background processing, thereby enforcing project-level isolation. The RAG system provides citation-grounded answers, role-based access control, and evaluation tracking. Across both systems, vibe coding accelerated scaffolding and integration. However, the generated code often under-specified isolation rules and infrastructure constraints when these were not explicitly defined. Consequently, aspects such as multi-tenancy, access control, memory policies, and asynchronous processing required deliberate architectural design and verification. We observe a shift in engineering effort from boilerplate implementation toward constraint specification and enforcement auditing. We also identify recurring architectural "non-delegation zones" where conversational code generation remains insufficient for production reliability.

Related papers

• MetaInfer: A Knowledge Only LLM Inference Engine Generator SKILL Toolbox [0.3581211034057412]
  This paper presents metainfer, an 'LLM-as-Compiler' approach in which users specify only the runtime constraints of an inference program.<n>An LLM-driven multi-agent collaboration system, coupled with a contract knowledge base, then automatically generates a compact customized inference framework.
  arXiv  Detail & Related papers  (2026-07-14T15:22:48Z)
• Meta-Engineering Harnesses for AI-Native Software Production: A Contract-Driven Adversarial Verification Architecture with Early Deployment Report [0.0]
  We present a software-production architecture that transforms operational and product feature requirements into explicit contracts.<n>We describe the layered architecture, including two-pass contract compilation.<n>We report results from an early production deployment spanning 17 features over several weeks.
  arXiv  Detail & Related papers  (2026-05-25T10:15:24Z)
• The Model Is Not the Product: A Dual-Pillar Architecture for Local-First Psychological Coaching [51.56484100374058]
  This report introduces Psych LM, an iOS application that validates the thesis that, for such applications, the surrounding architecture is paramount.<n>Psych LM runs a local, on-device language model within a purpose-built, local-first runtime designed for behavioral and life-coaching applications.
  arXiv  Detail & Related papers  (2026-05-23T05:49:11Z)
• Architectural Constraints Alignment in AI-assisted, Platform-based Service Development [32.505127447635864]
  We propose a retrieval-augmented scaffolding approach that combines platform-based code generation with agentic clarification loops to expose and resolve architectural constraint ambiguities.<n> Evaluation indicates improved architectural consistency and deployability compared to general-purpose AI code generation scaffolding.
  arXiv  Detail & Related papers  (2026-05-06T14:28:28Z)
• ReqToCode: Embedding Requirements Traceability as a Structural Property of the Codebase [0.0]
  This paper introduces ReqToCode, an approach that prevents trace degradation by embedding traceable system elements directly into the system.<n>We describe the approach, its architectural principles, the Traceable lifecycle, and illustrate it with a generic example spanning requirement definition, artifact generation, code integration, and build-time validation.
  arXiv  Detail & Related papers  (2026-03-14T16:00:09Z)
• Understanding by Reconstruction: Reversing the Software Development Process for LLM Pretraining [66.89012795621349]
  Large Language Models (LLMs) often struggle with the deep, long-horizon reasoning required for complex software engineering.<n>We propose a novel paradigm: understanding via reconstruction.<n>We introduce a framework that synthesizes latent agentic trajectories using a multi-agent simulation.
  arXiv  Detail & Related papers  (2026-03-11T09:23:20Z)
• Production-Grade AI Coding System for Client-Side Development [3.002720345105488]
  This paper presents a production-grade AI coding system designed for client-side development under realistic industrial constraints.<n>The system adopts a structured, multi-stage pipeline that integrates Figma designs, natural-language PRDs, and domain-specific engineering knowledge into explicit intermediate artifacts.
  arXiv  Detail & Related papers  (2026-03-02T05:17:55Z)
• ABC-Bench: Benchmarking Agentic Backend Coding in Real-World Development [72.4729759618632]
  We introduce ABC-Bench, a benchmark to evaluate agentic backend coding within a realistic, executable workflow.<n>We curated 224 practical tasks spanning 8 languages and 19 frameworks from open-source repositories.<n>Our evaluation reveals that even state-of-the-art models struggle to deliver reliable performance on these holistic tasks.
  arXiv  Detail & Related papers  (2026-01-16T08:23:52Z)
• Event Extraction in Large Language Model [99.94321497574805]
  We argue that EE should be viewed as a system component that provides a cognitive scaffold for LLM centered solutions.<n>This survey covers EE in text and multimodal settings, organizing tasks and taxonomy, tracing method evolution from rule based and neural models to instruction driven and generative frameworks.
  arXiv  Detail & Related papers  (2025-12-22T16:22:14Z)
• NL2Repo-Bench: Towards Long-Horizon Repository Generation Evaluation of Coding Agents [79.29376673236142]
  Existing benchmarks fail to rigorously evaluate the long-horizon capabilities required to build complete software systems.<n>We present NL2Repo Bench, a benchmark explicitly designed to evaluate the long-horizon repository generation ability of coding agents.
  arXiv  Detail & Related papers  (2025-12-14T15:12:13Z)
• Generating Software Architecture Description from Source Code using Reverse Engineering and Large Language Model [2.6126272668390373]
  Software Architecture Descriptions (SADs) are essential for managing the inherent complexity of modern software systems.<n>SADs are often missing, outdated, or poorly aligned with the system's actual implementation.<n>We propose a semi-automated generation of SADs from source code by integrating reverse engineering (RE) techniques with a Large Language Model (LLM)
  arXiv  Detail & Related papers  (2025-11-07T11:35:46Z)
• Towards Realistic Project-Level Code Generation via Multi-Agent Collaboration and Semantic Architecture Modeling [7.753074942497876]
  We introduce CodeProjectEval, a project-level code generation dataset built from 18 real-world repositories with 12.7 files and 2,388.6 lines of code per task.<n>We propose ProjectGen, a multi-agent framework that decomposes projects into architecture design, skeleton generation, and code filling stages.<n>Experiments show that ProjectGen achieves state-of-the-art performance, passing 52/124 test cases on the small-scale project-level code generation dataset DevBench.
  arXiv  Detail & Related papers  (2025-11-05T12:12:35Z)
• Context Engineering for Multi-Agent LLM Code Assistants Using Elicit, NotebookLM, ChatGPT, and Claude Code [0.0]
  Large Language Models (LLMs) have shown promise in automating code generation and software engineering tasks, yet they often struggle with complex, multi-file projects due to context limitations and knowledge gaps.<n>We propose a novel context engineering workflow that combines multiple AI components: an Intent Translator (GPT-5) for clarifying user requirements, an Elicit-powered semantic literature retrieval for injecting domain knowledge, and a NotebookLM-based document synthesis for contextual understanding, and a Claude Code multi-agent system for code generation and validation.
  arXiv  Detail & Related papers  (2025-08-09T14:45:53Z)
• Data Dependency-Aware Code Generation from Enhanced UML Sequence Diagrams [54.528185120850274]
  We propose a novel step-by-step code generation framework named API2Dep.<n>First, we introduce an enhanced Unified Modeling Language (UML) API diagram tailored for service-oriented architectures.<n>Second, recognizing the critical role of data flow, we introduce a dedicated data dependency inference task.
  arXiv  Detail & Related papers  (2025-08-05T12:28:23Z)
• Codev-Bench: How Do LLMs Understand Developer-Centric Code Completion? [60.84912551069379]
  We present the Code-Development Benchmark (Codev-Bench), a fine-grained, real-world, repository-level, and developer-centric evaluation framework. Codev-Agent is an agent-based system that automates repository crawling, constructs execution environments, extracts dynamic calling chains from existing unit tests, and generates new test samples to avoid data leakage.
  arXiv  Detail & Related papers  (2024-10-02T09:11:10Z)
• MLSmellHound: A Context-Aware Code Analysis Tool [4.157846027410602]
  Code analysis tools must account for the cultural differences within the teams which manifests as multiple programming languages. Existing tools fail to identify these cultural differences and are geared towards software engineering which reduces their adoption in machine learning projects. In our approach we attempt to resolve this problem by exploring the use of context which includes i) purpose of the source code, ii) technical domain,iii) problem domain, iv) team norms, v) development lifecycle stage. This allows for contextualised and meaningful error reporting for the end-user.
  arXiv  Detail & Related papers  (2022-05-08T06:01:22Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.