Natural language is now the primary programming interface.
With the increased use of AI coding agents, there is a strong need for disciplined methodologies.
Accountability is non-negotiable. So are compliance, data privacy, safety, and adherence to applicable laws.
Root causes of disasters waiting to happen
- Blindly prompting, vibe coding
- intent → implementation → production
What is the remedy?
We need to step back and develop new processes and strong ground-up methodologies. Retaining traceability may not be sufficient; we want to strengthen it by being more mindful of the new risks.
The common spine of any project (hardware development, hardware verification, software development, software verification, process definitions) is the same:
Requirements → Specifications → Implementation.
Do not skip requirements and specifications. Requirements and specifications must be fine-grained, version-controlled, and traceable. Both will have granularity levels. From project-level to leaf-level: Every level must be versioned and traceable. This isn't new; especially, the automotive segment has adhered to strong traceability and process requirements. But in the agentic AI era, many other projects also require a similar, if not higher, level of rigour.
Specifications at the finest level of granularity require precision - no ambiguity. At the finest granularity, the specification may continue to use well-specified grammar like programming languages, while the higher-level specification will lean more towards natural language. Specification then converts to the implementation (completely code-agent-generated).
This argument does not contradict the use of AI for requirements and specifications, but brings in ample determinism, traceability, and repeatability.
Having specifications and requirements at finer levels allows for more rigorous rule checks, hardware simulations, and software regressions.
For decades, engineering attention had a heavy focus on coding guidelines, code reuse, portability, memory safety, readability, and layered abstractions.
At least some of those focus areas were motivated by coding being expensive, hard to maintain, and by the need to stay within human cognitive abilities!
Implementation is easy now. Programming languages may change dramatically. The lowest level of specification needs defined grammar; would it be a declarative language? Declarative languages may be well suited for defining specifications and requirements. Are most other languages on their way out? Do we go directly from the fine-grained specifications to bytecode (software) or RTL gates (hardware)?
Remove the focus on implementation (maybe even entirely). But increase the focus towards the rigorous processes for the following view:
requirements, specifications × development, verification, process definitions
Time-to-market and resource constraints meant that striving for the utmost safety and compliance got only just about enough focus to pass the gate. There is probably no excuse now. Let us shift the focus more towards correctness, safety, and traceability. We have a real opportunity to step up and mitigate the risk. The right time is now.
Top comments (0)