The rise of large language model (LLM)-based coding assistants has introduced a new paradigm often referred to as vibe coding, a workflow in which developers express intent in natural language and rely on AI agents to generate source code. This approach is already reshaping software engineering practices, enabling rapid prototyping, automated refactoring, and even semi-autonomous development pipelines.
In non-critical domains, adoption has accelerated dramatically. Reports from major technology companies indicate that a substantial portion of production code is now AI-assisted or AI-generated. However, in safety-critical domains such as automotive, aerospace, and medical devices, the situation is fundamentally different. Here, software correctness is not enough; systems must be demonstrably safe, secure, and compliant with rigorous standards.
This article examines the applicability of vibe coding in safety-critical software development, outlining its benefits, inherent risks, and a pragmatic hybrid approach that aligns with functional safety expectations.
In this article, our definition of vibe coding describes workflows in which developers translate natural-language requirements into source code. We recognize that this interpretation may differ from some widely used definitions of the term.
The appeal of vibe coding
At its core, vibe coding reduces the friction between intent and implementation. Modern LLMs can translate natural language requirements directly into compilable code, significantly shortening development cycles.
Key advantages
Accelerated development cycles: AI-generated code enables rapid iteration from concept to prototype, and from prototype to production. This is particularly valuable in early-stage design, where requirements are still evolving.Increased developer throughput: By automating repetitive tasks such as boilerplate generation, test scaffolding, and refactoring, AI tools enable engineers to focus on higher-level design concerns.Improved accessibility: Less experienced developers can leverage AI assistance to produce code that would otherwise require deeper expertise, effectively lowering the barrier to entry.
These capabilities collectively make vibe coding highly attractive in environments driven by time-to-market pressures and increasing system complexity.
Why safety-critical systems are different
Despite these advantages, safety-critical software development imposes constraints that fundamentally challenge the viability of pure AI-driven code generation (AKA, vibe coding).
Non-determinism of LLMs: LLMs are inherently stochastic systems trained on heterogeneous datasets. Given the same input, they may produce different outputs, and there is no guarantee of adherence to strict constraints such as safety coding standards. This non-determinism is incompatible with certification requirements, which demand repeatability, traceability, and formal justification.High incidence of defects and vulnerabilities: Empirical studies show that a significant proportion of AI-generated code contains security flaws or violations of best practices that may lead to unpredictable behaviors. Unpredictable software is neither safe nor secure. Even though models continuously improve and produce better, more secure code, the growing body of research indicates that models cannot be trusted to produce code free from constructs that may lead to unpredictable behaviors and precisely implement specified requirements. One of the challenges is that models can violate design constraints and best coding practices if they are explicitly instructed to follow them.Lack of qualification frameworks: Standards and regulatory documents for the safety-critical systems enable using code generation tools in the development process, but they require these tools to be deterministic and define a special process of approving these tools for use in the safety critical software development. This process is called Tool Qualification or Tool Validation and aims at providing evidence that the tool behaves in a deterministic way and according to Tool Operational Requirements specification. Code generation tools that, for example, transform simulation models into source code, can satisfy these requirements. When a code generation tool is qualified, its output can be used in the critical system with limited or without any additional verification. With LLMs, the situation is fundamentally different. There are currently no accepted methodologies for qualifying LLM-based code generators under functional safety standards (e.g., ISO 26262, DO-178C, IEC 62304). Without tool qualification, their output cannot be trusted by default.
A critical principle: Verification is non-negotiable
The central conclusion emerging from both industry practice and current research is unequivocal: AI-generated code is not inherently trustworthy for safety-critical systems.
It becomes acceptable only when subjected to the same rigorous verification and validation (V&V) processes as human-written code.
This includes:
- Static code analysis
- Dynamic testing (unit, integration, system-level, SIL, PIL, HIL testing)
- Formal verification where applicable
- Security assessment
- Compliance verification against standards
- Traceability from requirements to implementation and tests
In other words, vibe-coding or AI-based code generation does not eliminate the need for traditional safety engineering practices, it amplifies their importance.
A hybrid of AI and deterministic verification
Given the limitations of standalone AI code generation, current research and experimental workflows converge on a hybrid model.
In this paradigm, AI is used for code generation from requirements, while deterministic tools flag potential defects and incompliance. Deterministic code analysis tools are combined with the AI-agent in a feedback loop. If a problem is detected in the generated code, the analysis tool emits a diagnostic message which is provided to the AI-agent with the remediation request. Agent attempts to fix the problem, and modified code is pushed through the pipeline again. The loop iterates until generated code satisfies all quality gates. It is then submitted for the human expert review.
The primary value of such a workflow lies in reducing the effort required for the final human review. Deterministic code analysis tools can automatically detect and help eliminate entire classes of issues, thereby lowering the time and effort needed to validate and approve the code. This kind of workflow is built on very well-established software testing automation processes.
At the high level, this concept looks very appealing. However, there are several challenges. First, the overall effectiveness of the process is bound by the capabilities of the deterministic tools integrated into the pipeline. Automated detection of defects in generated code is feasible only for specific classes of issues. A representative example is static analysis. Static analyzers can be incorporated as quality gates within the pipeline, where they systematically evaluate code against predefined rules. These tools are effective at identifying certain categories of defects (e.g., potential runtime errors, undefined behavior) and enforcing compliance with coding standards such as MISRA, thereby increasing confidence in AI-generated code.
When violations are detected, static analysis tools produce diagnostic outputs that are often structured and actionable. In many cases, these diagnostics can be consumed directly by an AI agent to remediate issues in the codebase. Beyond static analysis, additional verification and testing techniques, such as unit testing, property-based testing, and formal verification, can further enhance the robustness of this automated workflow.
The workflow assumes that the requirements document includes test cases specification. Requirements are provided to the AI agent with a request to generate the implementation (vibe-code). Test cases specification is used for generating unit, integration, and system level test cases. Generated code is then pushed through the collection gates which includes unit/integration/system level tests execution where generated test cases are executed against generated code. Test execution failures and code coverage results are provided to AI agent with the remediation requests. The remediation may include modification of generated code, modification of test cases, and generation of additional tests.
Once all the gates are satisfied, generated code is submitted for human expert review. Hypothetically, at this phase, it should be free from problems detectable by the quality gates. In parallel, another agent is tasked with a request to compile tool execution reports from all the quality gates and prepare the initial version of the safety documentation.
This workflow is intentionally simplified and does not capture the full complexity of real-world safety-critical software development. It serves to illustrate a key area of active research and the potential role of AI agents in such environments. The primary value lies in reducing the burden of final human review and approval by proactively eliminating certain classes of defects in AI-generated code.
An alternative approach is to equip an agent with a collection of skills, including information on how to build the code, how to run static analysis and execute various tests. In this approach agents have full autonomy in deciding what steps should be taken to achieve goals.
“Skills-based” approach is more aligned with the long-term strategy for using agents in the software development processes. However, currently, many teams prefer these stiffer approaches with strict control over agents’ activities. One of the reasons is that when working on large code bases, for example generating new feature for an existing code base, the cost of agent taking “unreasonable” action, like unnecessary rebuild of the code base, may be relatively high when measured in time and tokens.
Insights from an experimental workflow
A version of experimental workflow presented in Figure 3 was exercised internally. The goal was to check if it is possible to vibe-code a simple C++ program and automatically refine the AI-generated code with three gates including static analysis with MISRA guidelines enforcement, unit testing with MC/DC coverage, and integration testing also with code coverage. The team used several popular benchmarks with programming challenges. The conclusion was that the popular benchmarks do not contain sufficiently complex programming challenges to fully evaluate feasibility of using these kinds of workflows for automated refinement of vibe-coded implementation. So, a simpler research question was posed: Is it possible to vibe-code a simple C++ program and make it automatically compliant with MISRA C++:2023 coding guidelines?
The experimental setup used for this research is presented in the diagram below:
The outcome of this experiment was positive. The agent was able to generate functionally correct code for all cases and automatically enforce the MISRA C++:2023 coding standard compliance in the generated code. The chart below presents the number of iterations required to achieve MISRA C++:2023 compliant and functionally correct code implementation.
For 46 test cases out of the total 72, only two iterations of the workflow were required to produce functionally correct and MISRA C++:2023 compliant code. Only six test cases required six iterations to complete showing that it’s feasible to use static analysis in an automated feedback loop to ensure that AI-generated code complies with a popular industry standard frequently used for safety-critical software. Bottom line
Vibe coding is changing how software can be developed, offering substantial gains in productivity and flexibility. However, its application in safety-critical systems is constrained by the fundamental requirements of determinism, traceability, and verifiability.
Given current capabilities, vibe coding should not be viewed as a replacement for traditional safety-critical code development, but rather as an augmentation layer.
AI coding agents should be viewed as collaborators within a tightly controlled, verification-driven process. When used appropriately, they can enhance productivity without compromising safety—a balance that is essential for the future of critical systems development.
Read also:
[Engineering Education in the Age of AI](https://www.eetimes.com/engineering-education-in-the-age-of-ai/)
[EDA’s AI Revolution Meets Its Real-World Constraints](https://www.eetimes.com/eda-ai-revolution-meets-its-real-world-constraints/)