AI in SDLC: Why I Stopped Optimizing for Code Generation and Started Optimizing for Alignment

Harshil Kansagara — Sun, 07 Jun 2026 12:35:07 +0000

Over the past few months I built an AI-assisted delivery framework — not to write code faster, but to eliminate ambiguity across the entire software development lifecycle.

The result completely changed how I think about AI in engineering.

The problem I kept hitting

Every time I used AI to generate architecture docs, API contracts, or implementation plans across separate sessions, the outputs looked great in isolation. But viewed together? They were broken. A pivot in the system architecture was never reflected in the API contracts. Frontend assumptions silently diverged from backend data models.

AI wasn't the problem. Treating it as a collection of disconnected prompt sessions was.

What I built instead

A governance-driven framework built on three layers:

Prompt → Agent → Skill

The Prompt captures intent only — lightweight, declarative
The Agent orchestrates execution and decides which capabilities to invoke
The Skill is a reusable, schema-validated execution block with hardcoded governance rules

This connects every delivery artifact into a sequential dependency chain:

Business Requirements
    ↓
System Architecture
    ↓
Data Architecture
    ↓
Event Architecture
    ↓
API Contracts
    ↓
Implementation Plans
    ↓
Backend / Frontend Implementation

Each artifact consumes the one before it. Upstream changes automatically propagate downstream. Governance is enforced at the Skill layer — not buried in fragile prompts.

The finding that surprised me most

The highest-leverage use of AI wasn't code generation.

It was context generation.

When engineers — or downstream agentic workflows — were given a governed, unambiguous spec, implementation quality was consistently higher than any raw AI-generated code output. The context was the unlock, not the syntax.

What failed

I'm including this because most write-ups skip it:

Over-orchestrating everything (not every workflow needs an agent loop)
Prompt bloat as a substitute for real architecture
Severely underestimating token costs at scale
Believing full pipeline autonomy was a safe goal — it isn't

Full write-up

I covered the complete framework, the frontend design extraction layer, backend implementation with a real IAM module, the honest retrospective, and where this goes next in a detailed Medium article:

👉 AI-Driven SDLC: Beyond Code Generation to Delivery Orchestration