AI Writes Code. Enterprise Engineering Delivers Software.
René De Vleeschauwer, founder and CEO of IKAN, explains why the key to AI success lies beyond code generation
The conversation around AI in software development has changed dramatically over the past two years.
Models have become faster, more capable, and significantly more affordable. Solutions like IBM Bob Premium Packages for Z and i are enabling mainframe development teams to generate COBOL, explain legacy code, modernize applications and increase developer productivity in ways that were unimaginable just a few years ago.
For many organizations, the first question was: “Can AI help us write code?”
Today, that question has already been answered.
The more important question is: How do we operationalize AI across the entire software development lifecycle?
Because generating code is only one step in delivering production software.
Development Is Only the Beginning
Every experienced software engineer knows that writing code represents only a fraction of the software delivery process.
Enterprise software must also be:
- Reviewed
- Tested
- Integrated
- Validated
- Approved
- Deployed
- Monitored
- Audited
- Maintained
Introducing AI into this lifecycle doesn’t eliminate these responsibilities—it makes them even more important.
When AI contributes to software development, organizations must be able to answer questions such as:
- Which AI model generated this code?
- Which prompt produced this implementation?
- Which version of the model was used?
- Who reviewed the generated changes?
- Which tests validated the output?
- When was it deployed?
- Can the same result be reproduced months later?
Without these answers, AI remains an individual productivity tool rather than an enterprise software engineering capability.
AI Must Become Part of the SDLC
Organizations have spent decades building mature software development life cycle (SDLC) practices. They include version control, peer reviews, continuous delivery, automated testing, change management and release governance.
AI should not bypass these practices. It should strengthen them.
Every AI-assisted artifact—whether it’s generated code, prompts, documentation, unit tests or architecture recommendations—should become a managed software artifact with the same engineering discipline applied to traditional source code.
CI/CD for AI
Most organizations already have mature CI/CD pipelines. The challenge is extending those pipelines to AI-assisted development.
That means treating prompts, AI workflows, generated artifacts and model configurations as version-controlled assets.
Every change should be:
- Committed
- Reviewed
- Automatically tested
- Validated
- Approved
- Released
Instead of developers experimenting with isolated prompts, organizations build repeatable engineering pipelines that consistently produce high-quality outcomes.
AI becomes another component of the delivery pipeline—not an exception to it.
Governance Cannot Be an Afterthought
As AI adoption grows, governance becomes one of the largest challenges.
Organizations need clear answers to questions such as:
- Which AI models are approved?
- Which teams may use them?
- Which repositories may invoke AI?
- Which environments allow code generation?
- Which prompts are considered production-ready?
- Which generated changes require additional review?
- Which policies apply to regulated applications?
These questions cannot be answered through documentation alone. Governance must become embedded within the engineering platform itself. Policies should be enforced automatically rather than relying solely on individual developers following best practices.
Auditability Creates Trust
Enterprise software development already produces extensive audit trails. AI should extend—not weaken—that traceability.
Every AI-assisted change should provide a complete history, including:
- User
- Repository
- Branch
- Prompt
- AI model
- Model version
- Generated output
- Human modifications
- Review decisions
- Test results
- Deployment history
This level of transparency becomes essential in regulated industries such as banking, insurance, healthcare, telecommunications and government.
When an auditor asks, “How was this code produced?” the answer should already exist.
Repeatability Matters More Than Generation
One of the biggest risks of AI adoption is inconsistency. Two developers asking nearly identical questions may receive different implementations.
Over time, prompts evolve. Models and context change. Without standardization, engineering practices quickly diverge.
Successful organizations don’t optimize for individual prompts. They optimize for repeatable engineering processes.
Think reusable prompt libraries, AI workflows, shared development templates, controlled model configurations, common review processes and reusable deployment pipelines.
These practices allow organizations to scale AI safely across hundreds or thousands of developers.
Standardization Enables Scale
The organizations realizing the greatest value from AI are not necessarily those with the most advanced models. They are the ones that standardize how AI is used.
Instead of every team inventing its own workflows, organizations define reusable patterns that can be adopted enterprise-wide.
Standardization delivers:
- Consistent code quality
- Faster onboarding
- Lower operational risk
- Easier governance
- Reduced maintenance
- Predictable delivery
- Higher developer confidence
The result is AI that behaves like an enterprise capability rather than a collection of isolated experiments.
The Platform Layer
This is where the next phase of enterprise AI begins.
Solutions like the IBM Bob Premium Packages for Z and i provide the intelligence that accelerates software development. But organizations also need a platform that operationalizes that intelligence across the entire software delivery lifecycle.
That platform should provide:
- AI-aware CI/CD pipelines
- Lifecycle management for prompts and AI workflows
- Enterprise governance and policy enforcement
- Complete audit trails
- Repeatable engineering practices
- Standardized development workflows
- Integration with existing DevOps toolchains
- Support for collaboration across development teams
The goal is not simply to generate more code. The goal is to build software that is trusted, governed, maintainable and ready for production.
The Future of AI in Software Engineering
AI will undoubtedly transform software development, but the winners will not be the organizations that generate the most code. They will be the organizations that successfully integrate AI into disciplined software engineering practices.
The future is not AI replacing software engineering. The future is AI becoming an integral part of a governed, auditable, repeatable and automated software delivery lifecycle.
Because writing code is only the beginning. Delivering enterprise software is what truly creates value.