Leveraging artificial intelligence to accelerate software development has become a standard approach for modern Business Analysts (BAs) and product owners. However, treating AI as a magic box that generates production-ready code without strict analytical governance is a recipe for severe technical debt.
This article analyzes a real-world experiment using AI to build an application, mapping the core failures to the BABOK v3 Guide to show how unstructured “vibe coding” compromises software quality.
The Experiment: Setup and Tooling
The goal was to build a new project by reusing a proven, highly portable mobile and web technical stack. To accelerate the timeline, the integrated development environment (IDE) was connected to a free online AI model.
Initial local attempts using Ollama on a powerful hardware setup—a 24 GB VRAM RTX 3090—proved disappointing. The local models struggled to adapt to the specific requirements or maintain situational awareness. Because the project’s eventual goal was an open-source release, data privacy was not an obstacle, allowing the workflow to transition entirely to the superior free online AI.
The development started small, feeding incremental feature requests to the model. While the initial output was functional, scaling the application quickly exposed the deep systemic flaws of relying on unstructured AI generation.
The “Bad Way” to Use AI: Technical and Analytical Breakdown
When a BA delegates implementation to an AI without robust structural guardrails, the development process rapidly degrades due to several core issues:
1. The Knowledge Cutoff and Constraint Amnesia
The online model utilized was slightly outdated, meaning it lacked knowledge of recent framework updates. It routinely forgot critical technical constraints that emerged after its training phase. To keep the project compiling, the same technical parameters had to be manually repeated in the prompt history over and over again.
2. Context Blindness and Regression Failures
As feature complexity increased, the application frequently broke. The AI lacked the long-term context retention required to respect previously implemented features. Adding a new component regularly destroyed existing logic, requiring exhausting cycles of manual testing to catch regressions.
3. Structural Fragmentation and Code Duplication
Instead of maintaining modularity, the AI constantly redeveloped similar code differently in multiple parts of the codebase. This fragmentation made bugs exceptionally difficult to isolate and fix. When asked to refactor its own messy architecture, the AI’s output was unusable. Manual refactoring proved to be significantly faster and cleaner.
4. Non-Functional Requirement Neglect
The model routinely ignored global system constraints. For example, it failed to treat user interface (UI) translation as a hard architectural rule. Every time a new feature was generated, the AI skipped making the text translatable, breaking localization standards.
The BABOK v3 Perspective: Why the Workflow Failed
From a Business Analysis standpoint, these technical hurdles stem from a failure to apply foundational BABOK v3 disciplines:
- Requirements Analysis and Design Definition (Chapter 7): Skipping the definition of a rigid system architecture before implementation allowed the AI to introduce severe structural flaws. BAs must specify requirements and structure design options before code generation begins.
- Solution Evaluation (Chapter 8): Relying on manual testing to verify code stability is an analytical failure. Without automated verification frameworks, the true value and performance of the solution cannot be accurately analyzed.
- Requirements Life Cycle Management (Chapter 5): The model’s tendency to break old code when adding new features highlights a lack of requirements traceability. BAs must ensure that solution components maintain their relationship to the broader scope throughout the life cycle.
Core Takeaways for Strategic Business Analysis
To successfully implement AI-assisted development in mid-2026, BAs must pivot from passive “vibe coding” to strict structural governance:
- Define Architecture First: Establish a strict, pre-defined technical architecture and enforce absolute anti-duplication rules before prompting the AI.
- Incorporate Automated Testing: Any solution intended for long-term maintenance requires an immediate up-front investment in automated testing frameworks.
- Mandate Human Code Reviews: Once a project reaches moderate complexity, human oversight is non-negotiable. Every AI-generated change must be audited by an experienced engineer.
- Deploy Rules to Combat Stubbornness: Address model amnesia and behavioral issues by using rigid system instructions, system prompts, or
.cursorrulesfiles. - Prioritize Model Recency: Frameworks evolve rapidly. Utilizing a recently trained model dramatically increases efficiency by ensuring alignment with modern software versions.
- Sequence Non-Functional Requirements Strategically: Defer exhaustive UI localization and translation tasks to the final phases of the project lifecycle to prevent repetitive, time-consuming prompting loops during active feature building.
- Evaluate Local Capabilities Continually: While free online models currently outperform local options as of mid-2026, local capabilities are evolving. Highly optimized, smaller open-weight models—such as the promising
gpt-oss:20bhighlighted in recent industry benchmarks—warrant future evaluation to see if they can match online performance on local hardware.
Leave a Reply