PaperlayerView exact revision on arXiv

Source-linked AI summary

A Survey of Vibe Coding with Large Language Models

Yuyao Ge, Lingrui Mei, Zenghao Duan, Tianhao Li, Yujia Zheng, Yiwei Wang, Lexin Wang, Jiayu Yao, Tianyu Liu, Yujun Cai, Baolong Bi, Fangda Guo, Jiafeng Guo, Shenghua Liu, Xueqi Cheng

arXiv:2510.12399v2cs.AI

TL;DR

Vibe Coding’s effectiveness remains under-explored despite coding agents’ shift toward autonomous software development and evidence of productivity and collaboration challenges. This survey reviews over 1000 papers, formalizes Vibe Coding, and synthesizes five development models; it concludes that successful practice depends on context engineering, development environments, and human-agent collaboration.

  • Problem

    Vibe Coding’s effectiveness and human-AI collaboration challenges remain under-explored despite the emergence of autonomous coding agents.

  • Method

    The survey analyzes over 1000 papers, formalizes Vibe Coding as a Constrained Markov Decision Process, and synthesizes five development models across its ecosystem.

  • Results

    The survey identifies five Vibe Coding models and concludes that successful practice depends on systematic context engineering, established development environments, and human-agent collaboration.

  • Takeaways & Limitations

    Vibe Coding requires more than capable agents: practical deployment also depends on context engineering, infrastructure, feedback, and collaborative development strategies.

  • Takeaways & Limitations

    Vibe checks provide rapid iteration but lack the rigor of formal quality assurance, motivating structured testing such as the Test-Driven model.

Abstract

from arXiv · show

The advancement of large language models (LLMs) has catalyzed a paradigm shift from code generation assistance to autonomous coding agents, enabling a novel development methodology termed "Vibe Coding" where developers validate AI-generated implementations through outcome observation rather than line-by-line code comprehension. Despite its transformative potential, the effectiveness of this emergent paradigm remains under-explored, with empirical evidence revealing unexpected productivity losses and fundamental challenges in human-AI collaboration. To address this gap, this survey provides the first comprehensive and systematic review of Vibe Coding with large language models, establishing both theoretical foundations and practical frameworks for this transformative development approach. Drawing from systematic analysis of over 1000 research papers, we survey the entire vibe coding ecosystem, examining critical infrastructure components including LLMs for coding, LLM-based coding agent, development environment of coding agent, and feedback mechanisms. We first introduce Vibe Coding as a formal discipline by formalizing it through a Constrained Markov Decision Process that captures the dynamic triadic relationship among human developers, software projects, and coding agents. Building upon this theoretical foundation, we then synthesize existing practices into five distinct development models: Unconstrained Automation, Iterative Conversational Collaboration, Planning-Driven, Test-Driven, and Context-Enhanced Models, thus providing the first comprehensive taxonomy in this domain. Critically, our analysis reveals that successful Vibe Coding depends not merely on agent capabilities but on systematic context engineering, well-established development environments, and human-agent collaborative development models.

1 Introduction

Vibe Coding emerges as coding agents advance from code-generation assistance to autonomous environmental interaction, while effective human-AI collaboration remains constrained by task complexity and insufficiently structured instructions. This survey formalizes the paradigm and organizes its ecosystem and workflows into a systematic framework.

  • 1 Introduction: Coding agents autonomously complete programming tasks through shell commands, file operations, and test execution, with SWE-bench results rising from 12.5% for SWE-agent to 53% for OpenHands Verified.The cited progression also includes AutoCodeRover at 19.0%, Agentless at 27.3%, and self-improving agents’ 17–53% gains on SWE-bench Verified.
  • 1 Introduction: Vibe Coding has developers articulate requirements, observe execution, and provide feedback without inspecting AI-generated code line by line.Coding agents also configure environments, diagnose errors, and update implementations.
  • 1 Introduction: Experienced developers using Cursor with Claude experienced 19% increased completion time, highlighting limitations of unstructured instructions for complex tasks.The survey links effective collaboration to prompt engineering, context engineering, structured instructions, and balanced agency distribution.
  • 1 Introduction: The survey formalizes Vibe Coding as a dynamic relationship among human developers, software projects, and coding agents using a Constrained Markov Decision Process.It presents this as the first formal definition of Vibe Coding as an engineering discipline.
  • 1 Introduction: The survey synthesizes workflows into five models: Unconstrained Automation, Iterative Conversational Collaboration, Planning-Driven, Test-Driven, and Context-Enhanced.Its framework also addresses infrastructure, security mechanisms, and human factors.

2 Related Work

Related work spans foundational language models, prompting and context engineering, post-training, agent systems, reinforcement learning, autonomous coding, function calling, and supervised fine-tuning. Together, these strands establish the technical components underlying coding agents and their interaction with software environments.

  • 2 Related Work: Foundational surveys cover LLM architectures, training paradigms, efficient and long-context models, and the historical development from BERT to ChatGPT.They also examine opportunities, risks, and specialized evaluation and efficiency concerns.
  • 2 Related Work: Prompt engineering, in-context learning, context engineering, and Chain-of-Thought reasoning provide methods for using pretrained models without additional training.Related surveys organize prompting methods, applications, security considerations, and Chain-of-X paradigms.
  • 2 Related Work: Post-training research includes PPO, Q-Learning, Actor-Critic methods, RLHF, RLAIF, and DPO for aligning models and enhancing reasoning.These methods are surveyed as alternatives when in-context learning is insufficient.
  • 2 Related Work: Agent-system research combines tool use, planning, autonomous decision-making, multi-agent communication, and collaborative workflows across reasoning and code-generation benchmarks.This literature provides unified taxonomies for agent construction and multi-agent systems.
  • 2 Related Work: Autonomous coding research covers custom agent-computer interfaces, structure-aware code search, role-based collaboration, chat chains, human programming cycles, test-driven development, and self-repair.Function-calling studies further develop tool interaction through APIs, teacher-generated data, and multi-task learning.
  • 2 Related Work: Supervised and instruction-tuning methods include instruction evolution, self-instruction, transparent self-alignment, and large-scale instruction data for code models.These approaches complement reinforcement-learning-based training.

3 Vibe Coding: The Engineering of Managing Coding Agents

Vibe Coding is framed as an engineering methodology in which humans, projects, and coding agents form a dynamic, feedback-driven system. Its effectiveness depends on orchestrating project context, evolving requirements through supervision, and dividing responsibility across the three entities.

  • Formalization of the Triadic Relationship: Vibe Coding models software development as a triadic collaboration among humans, projects, and coding agents, formalized as a Constrained Markov Decision Process.Humans define goals and constraints, projects provide state and transition constraints, and agents execute policies and state transitions.
  • Agent’s Conditional Generation Process: Agent generation conditions code on human intent, relevant project context, and the execution environment through dynamically assembled context.The agent generates code autoregressively while the high-level assembly function orchestrates context at each step.
  • Optimization Objective of Vibe Coding: Context orchestration retrieves and filters project information to maximize generation quality within a limited context window.The relevant context may include instructions, code, databases, domain knowledge, tools, memory, and current tasks.
  • Human-Agent Collaborative Loop and Task Evolution: Continuous human feedback can refine implementations locally or expand the requirement set as execution exposes implicit requirements and boundary cases.Requirements evolve monotonically from an initial instruction set, enabling progressive clarification and adaptive specification refinement.
  • Formalization of the Triadic Relationship: Humans articulate intent and judge quality, projects constrain the solution space, and agents generate, modify, and debug implementations.This division assigns humans the What and Why, projects the Where, and agents the How.
  • Implications of Vibe Coding: Vibe Coding aims to give individual developers team-scale capabilities, continuous development and quality convergence, and a broader software creator ecosystem.The survey associates these benefits with cross-domain agent expertise, automated iteration, and natural-language creation interfaces.

4 Large Language Models for Coding

Coding LLMs are built through curated data pipelines, specialized pre-training objectives, continual pre-training, and post-training methods that improve coding and instruction-following capabilities.

  • Training Data and Instruction Tuning: Training-data quality relies on extensive filtering, syntax validation, quality assessment, deduplication, and rewriting across large multilingual corpora.RefineCode applies more than 130 language-specific rules across 607 languages, while SwallowCode uses a four-stage processing pipeline.
  • Training Data and Instruction Tuning: Code-model training combines permissively licensed repositories with synthetic instructional data, while instruction tuning improves instruction-following and solution generation.Instruction datasets evolved toward scalable synthetic generation methods that reduce annotation costs while maintaining quality.
  • Pre-training Objectives: Pre-training objectives include autoregressive prediction, masked language modeling, denoising, structure-aware learning, and contrastive learning for different coding capabilities.Masked language modeling supports bidirectional code understanding, whereas autoregressive objectives underpin generation and completion.
  • Continual Pre-training Strategies: 20% average performance improvement resulted from Qwen2.5-Coder’s 7:2:1 code, text, and mathematics data mix over code-only training.The mixture was selected through systematic experimentation during continual pre-training.
  • Continual Pre-training Strategies: Continual pre-training extends general-purpose models with specialized coding knowledge, but catastrophic forgetting and stability gaps remain active challenges.Replay of 30% of original pre-training data is one strategy for preserving previously learned capabilities.
  • Supervised Fine-tuning: Supervised fine-tuning adapts pretrained models to targeted applications through carefully curated labeled examples while retaining broad foundational knowledge.The section emphasizes that data quality and selection can matter more than dataset quantity.

Memory Mechanism

The selected passages describe coding-agent architecture through cognitive, memory, and tool-related components, while emphasizing reinforcement learning’s capabilities and unresolved limitations.

  • Coding Agent Architecture: Figure 5 organizes coding-agent architecture around a Cognitive System, Memory Mechanism, and Tool Integration supporting planning, action execution, and multi-agent collaboration.The figure presents these as core components and capabilities for coordinated software-development tasks.
  • Post-training and Agent Capabilities: Reinforcement learning advances code generation through reward-guided training, including actor-critic systems that learn functional correctness signals.CodeRL exemplifies this approach by using critic predictions to guide code-generating actors.
  • Post-training and Agent Capabilities: RL post-training remains constrained by catastrophic forgetting, reward hacking, instability on small models, sample inefficiency, and exploration–exploitation tradeoffs.Substantial benefits are reported primarily for models ranging from 8 billion to 670 billion parameters.

5 LLM-based Coding Agent

LLM-based coding agents combine planning, memory, tool use, self-reflection, and multi-agent collaboration to execute increasingly complex software tasks.

  • Planning Mechanisms: Planning decomposes complex tasks into subtasks and uses chain-of-thought, adaptive planning, feedback, memory, or search to improve agent reasoning and execution.The passages also caution that LLMs may hallucinate incoherent plans despite proper instructions.
  • Memory Mechanism: Memory mechanisms extend agents beyond static context windows by preserving codebase knowledge, patterns, and debugging histories through reading, writing, reflection, retrieval, and updating.Implementations distinguish short-term context-window memory from long-term parametric or external non-parametric memory.
  • Memory Mechanism: Short-term memory supports immediate feedback integration, while MemTool achieves 90-94% efficiency through dynamic memory management.FALCON demonstrates hierarchical short-term-memory organization for feedback integration.
  • Tool Integration: Tool integration enables agents to plan, execute, and interact with compilers, debuggers, version-control systems, and other external tools.Executable code-based tool frameworks allow dynamic revision and composition beyond predefined JSON-based actions.
  • Self-reflection: Self-reflection shifts coding from one-shot generation toward iterative refinement, with in-execution debugging showing more promise than post-execution review.Advanced systems search across multiple debugging paths to identify better revisions.
  • 5.5.2 Framework Implementations: 93.9% on HumanEval, 83.1% on MBPP, 22.0% on APPS, 28.5% on CodeContests, and 45.3% on xCodeEval were achieved by MapCoder.MapCoder uses four specialized agents, illustrating the performance potential of role-based collaboration.

6 Development Environment of Coding Agent

Coding-agent development environments combine isolated execution infrastructure, security controls, AI-native interfaces, and collaborative protocols to support reproducible human–AI programming. Reliable deployment still requires human verification and coordination mechanisms because multi-agent systems face communication and consistency challenges.

  • Execution and Security: Containerized and sandboxed execution provides coding agents with reproducible environments, lightweight isolation, and controlled resource use for repeatedly running generated code.Docker, Kubernetes, sandboxes, and related isolation technologies constrain file, process, network, and resource access.
  • Execution and Security: Cloud orchestration scales agent execution through isolated pods, dynamic resource allocation, timeouts, persistent artifacts, and support for multiple programming languages.Distributed deployments separate execution workloads while maintaining reproducible compute environments and stored logs or results.
  • AI-Native Development Interfaces: AI-native IDEs combine inline completion with conversational interaction, while contextual memory and multi-turn reasoning improve assistance coherence.Inline suggestions support rapid iteration, whereas dialogue supports intent specification, explanations, and debugging.
  • AI-Native Development Interfaces: Protocol integration lets coding agents request, modify, and analyze project context while remaining compatible with IDEs and version-control systems.This convergence supports an open environment for hybrid human–AI programming collaboration.
  • Collaborative Development Infrastructure: Agent participation extends CI/CD with code generation, analysis, and self-testing, but human oversight remains necessary for critical verification.Multi-agent frameworks add fault tolerance, role specialization, and iterative verification, while communication overhead and semantic drift remain challenges.

7 Feedback Mechanisms

Feedback mechanisms transform code generation into iterative refinement using compiler, runtime, static-analysis, testing, clarification, and self-evaluation signals. Their effectiveness depends on feedback quality and external grounding, while unreliable tests, limited coverage, and self-correction constraints remain important boundaries.

  • Compiler and Static-Analysis Feedback: 69-81% accuracy in warning prioritization and 81.13% precision with 94.64% recall show that LLMs can assist static-analysis interpretation at scale.Static analysis still produces many warnings, including false positives, requiring prioritization and inspection.
  • Execution and Testing Feedback: Compiler, runtime, and test feedback convert one-shot code generation into iterative refinement, with structured test feedback producing the highest repair success rates.Feedback categories include compilation errors, failed tests, and runtime outcomes; CompCoder increased compilation success from 44.18% to 89.18%.
  • Execution and Testing Feedback: Generated unit tests can mislead refinement because they may be unreliable, computationally expensive at scale, and incomplete for edge cases or complex scenarios.These limitations can allow buggy code to pass initial validation or create circular dependencies in self-improvement.
  • Interactive Requirement Clarification: 45.97% average absolute improvement in pass@1 code-generation accuracy within five user interactions demonstrates the value of clarification when requirements are underspecified.Models still struggle to distinguish well-specified from underspecified instructions, but interaction can obtain vital information from users.
  • Self-Evaluation and Critique: Self-correction works primarily with reliable external feedback, and effective self-evaluation may require large-scale fine-tuning despite gains from critique and refinement frameworks.Reflexion reached 91% pass@1 on HumanEval versus 80% for GPT-4, an 11-point improvement, while Self-Refine reported approximately 20% absolute gains across applications.

8 Vibe Coding Development Models

The survey classifies Vibe Coding through human quality control, structured constraints, and context management, yielding four workflow models plus a composable context-enhancement capability. The models trade autonomy, planning, testing, and contextual alignment against review effort, risk, and project complexity.

  • Framework Principles: The framework identifies UAM, ICCM, PDM, TDM, and CEM across human quality control, structured constraints, and context management dimensions.CEM is a horizontal enhancement capability rather than an independent workflow, and the models can be combined.
  • Unconstrained Automation Model: Unconstrained Automation minimizes code scrutiny and validates functionality through testing, making it suitable for low-risk prototypes but not production or safety-critical systems.The model risks security vulnerabilities, technical debt, maintenance difficulty, and unpredictable behavior as projects grow.
  • Iterative Conversational Collaboration Model: Iterative Conversational Collaboration keeps humans responsible for reviewing and understanding outputs while using repeated dialogue to refine implementations.It supports velocity, standards compliance, and maintainability, but requires developer discernment and increases review and testing costs.
  • Planning-Driven Model: Planning-Driven development uses human-authored architecture, specifications, and progressive implementation to reduce directional drift and improve modularity for complex applications.Its architecture-first approach organizes module decomposition, data structures, and feature planning before coding begins.
  • Test-Driven Model: Test-Driven development treats tests and acceptance criteria as precise constraints, replacing much manual auditing with automated behavioral verification.Comprehensive test suites require upfront investment but support continuous assurance and refactoring confidence in critical or long-lived codebases.
  • Context-Enhanced Model: Context-Enhanced development layers retrieval, indexing, documentation, and rules onto other models to improve consistency during large-codebase maintenance and cross-file changes.It can be combined with UAM, ICCM, or PDM to provide different balances of speed, control, and contextual alignment.

9 Future Impact and Open Challenges

Vibe Coding compresses software development into iterative prompt-generation-validation cycles, shifting developers toward orchestration, context engineering, and system-level oversight. This acceleration creates unresolved challenges for testing rigor, estimation, review, collaboration, and enterprise adoption.

  • From Phased Lifecycles to Continuous Micro-Iterations: Vibe Coding compresses development into iterative prompt-generate-validate cycles, replacing longer phased progression with continuous goal-satisfaction exchanges.The cycle can operate over seconds or minutes rather than the weeks typical of Agile sprints.
  • Requirements and Design: Design emerges through exploratory dialogue as developers iteratively refine requirements by interacting with AI-generated prototypes.High-level user stories are translated into prompts, and prototype interaction refines requirements in real time.
  • Implementation: Coding agents handle more syntactic construction while developers increasingly act as system directors, prompt engineers, and architectural overseers.Human responsibility shifts toward system structure, component interaction, technology choices, and conceptual integrity.
  • Testing and Validation: Continuous informal acceptance testing accelerates feedback but lacks the rigor of formal quality assurance, motivating Test-Driven workflows with verifiable targets.In Test-Driven development, developers define formal tests that agents must generate code to pass.
  • Redefinition of Developer Roles and Skillsets: Successful adoption requires prompt engineering, context curation, system-level debugging, and architectural oversight, while mature context-management infrastructure remains unavailable.Practitioners must provide APIs, schemas, code snippets, and design patterns that constrain generation effectively.
  • Project Management and Collaboration: Vibe Coding complicates effort estimation, code review, and team collaboration, while large-scale enterprise case studies remain under-explored.Teams may shift from pair programming toward shared prompt and context design, but the enterprise implications remain largely theoretical.

9.2 Code Reliability and Security in Vibe Coding

Vibe Coding trades development speed for uncertainty because outcome-based validation can miss subtle reliability and security flaws. The survey therefore advocates embedding contextual security guidance, real-time static analysis, sandboxed dynamic analysis, and human risk judgment into the interactive loop.

  • Reliability and Security Risks: Vibe Coding’s speed-versus-certainty trade-off can allow subtle bugs, race conditions, resource leaks, and security vulnerabilities to pass outcome-based validation.The risk arises when developers approve generated implementations based on observed behavior rather than line-by-line understanding.
  • Integrated Feedback Loop: A robust workflow should couple coding agents directly with SAST, DAST, and quality-analysis tools inside the prompt-generate-validate cycle.The proposed architecture embeds automated analysis in the interactive workflow rather than delaying it to conventional pipeline scans.
  • Pre-Generation Contextual Analysis: Pre-generation contextual analysis can detect security-sensitive prompts and inject secure coding guidance or templates before code is produced.Keywords such as authentication, file upload, and SQL query can trigger security-specific context.
  • In-flight SAST Scanning: In-flight SAST can scan incomplete streamed code, return vulnerability information to the language model, and prompt self-correction before developer review.AI-enhanced scanners are designed to analyze partial snippets with fewer false positives than traditional complete-code workflows.
  • Sandboxed Dynamic Analysis: Sandboxed dynamic analysis can monitor execution for runtime failures and fuzz newly generated interfaces, complementing static analysis.The sandbox can detect memory leaks, uncaught exceptions, insecure network communications, and edge-case vulnerabilities.
  • Human Judgment and Threat Modeling: Automated security tooling supports developers but does not replace them: humans must interpret findings, resolve ambiguity, and make final risk-based decisions.The intended outcome is immediate actionable intelligence integrated into development rather than a separate delayed security phase.

9.3 Scalable Oversight of Vibe Coding Agents

As coding agents operate across repositories, pipelines, and environments, localized verification no longer scales to system-level governance. The survey identifies cascading errors, dependency proliferation, and alignment failures, then describes layered oversight using automated analysis, weak-to-strong supervision, critique, and continuous monitoring.

  • Emerging Risks of Vibe Coding Workflow: Autonomous agents require system-level governance because production-scale operation expands oversight from localized code verification across repositories, pipelines, and environments.Human-centric verification processes struggle to scale with agent autonomy, speed, and opaque decision pathways.
  • Emerging Risks of Vibe Coding Workflow: A tenfold increase in security warnings and technical debt accumulation within six months correlates with introducing autonomous agents into production pipelines.The cited empirical analyses characterize this as a correlation rather than a demonstrated causal effect.
  • Cascading Errors: Cascading errors can propagate a single agent’s insecure or malformed output through interconnected multi-agent pipelines into systemic failures.Downstream agents may consume and redeploy flawed completions, amplifying local inaccuracies.
  • Dependency Proliferation: Dependency proliferation expands opaque software linkages, with nearly one-fifth of code-generation package suggestions reported as nonexistent or untrusted.Such dependencies increase security and maintainability challenges and create opportunities for dependency-confusion attacks.
  • Alignment Failures: Alignment failures arise when agents optimize explicit task metrics while disregarding implicit safety, maintainability, or governance constraints.The problem reflects probabilistic interpretation of underspecified objectives rather than deterministic compilation.
  • Toward Scalable Oversight Architectures: Oversight scalability has limits: success rates decline sharply when an agent surpasses its overseer by several hundred Elo points.This boundary motivates continuous co-evolution between oversight systems and coding agents.
  • Toward Scalable Oversight Architectures: Scalable oversight combines hierarchical weak-to-strong supervision, multi-agent critique, and automated watchdogs to amplify limited feedback into governance constraints.These mechanisms are intended to evolve alongside agent capabilities while preserving human-aligned controls.

9.4 Human Factors in Vibe Coding

Vibe Coding shifts software engineering from direct code manipulation toward context engineering, specification, verification, and revision. This reconfiguration broadens required skills and changes collaboration, while raising unresolved concerns about trust, accountability, oversight capacity, education, and organizational roles.

  • Shifting Developer Mental Models: Vibe Coding recasts developers as context engineers who curate prompts, background information, and system constraints to guide generated output.The central task shifts from translating requirements directly into code toward structuring the conditions for generation.
  • Shifting Developer Mental Models: Developers increasingly follow a specify-verify-revise workflow in which prompting substitutes for manual implementation and verification becomes the central human activity.The workflow aligns software engineering more closely with product design and requirements engineering.
  • Emerging Developer Skillsets: Required competencies expand to prompt and context design, task decomposition, quality supervision, automated verification, agent governance, and security.Complex problems are more effectively handled when decomposed into explicitly defined subtasks, while oversight addresses bugs, vulnerabilities, and hallucinated APIs.
  • Emerging Developer Skillsets: These skill demands reposition developers from code producers toward supervisors and orchestrators of AI-driven workflows.Responsibilities include managing access control, execution privileges, provenance, testing, and formal verification.
  • Team Collaboration and AI Integration: AI tools can function as quasi-team members by taking on junior-development tasks, but existing review processes are inadequate for the scale and pace of generated code.Proposed responses include automated verification pipelines, provenance watermarks, and formal verification methods.
  • Team Collaboration and AI Integration: Developers report risks of over-reliance and automation bias, while responsibility for vulnerabilities may remain unclear among developers, reviewers, and AI providers.Effective trust calibration requires avoiding both blind acceptance and excessive skepticism.
  • Education and Organizational Change: Education and organizational structures may need to prioritize prompting, AI governance, human-AI collaboration, product design, requirements engineering, and test creation as implementation becomes more automated.Without curricular reform, future developers may lack the skills required for effective oversight.

10 Conclusion

The paper establishes Vibe Coding as a principled discipline through a formal human-project-agent framework, a five-model taxonomy, and a broad ecosystem synthesis. It emphasizes context engineering, executable feedback, and human oversight as central to reliable agentic software development.

  • Vibe Coding is formalized as a constrained decision process coupling human intent, project context, and coding-agent policies.The formulation specifies roles, interfaces, and optimization targets for agentic software development.
  • The survey unifies existing practices into five development models that can be composed for distinct risk, speed, and governance requirements.The models are Unconstrained Automation, Iterative Conversational Collaboration, Planning-Driven, Test-Driven, and Context-Enhanced.
  • Context management and executable feedback loops, rather than model quality alone, determine performance and maintainability in long-horizon software tasks.The synthesis covers model training, agent planning and memory, tool-mediated action, execution infrastructure, and compiler, runtime, human, and self-refinement feedback.
  • A three-axis taxonomy organizes human quality control, structured constraints, and context management as a vocabulary for engineering workflow trade-offs.These axes support selecting and composing workflow patterns for project-specific requirements while maintaining system coherence.
  • The survey connects Vibe Coding to organizational and educational changes involving context engineering, verification, task decomposition, agent governance, accountability, and trust.It grounds recommendations for training, process design, and governance in human-in-the-loop oversight.
  • The paper synthesizes formal foundations, five development models, ecosystem components, and challenges spanning infrastructure, security, and human factors.Its contributions position context engineering as central to practical deployment.
Loading 2510.12399v2…