Forem: Afzal Shaikh

AI in enterprise SDLC only works when Context, Constraints, and Collaboration are engineered

Afzal Shaikh — Tue, 21 Apr 2026 07:03:02 +0000

Most AI adoption in SDLC improves local productivity.
Enterprise delivery fails for a different reason.

It violates the 3C model: Context, Constraints, and Collaboration.

Consider a modernization example:

Context:
Eligibility and approval rules existed across legacy code, PDFs, and tribal knowledge.
AI-assisted discovery extracted them accurately.

Constraints:
Architects made a deliberate decision to externalize these rules for regulatory change.
That constraint existed only in documents.

Collaboration:
Developers and QA used AI independently to generate services and tests.

Six sprints later:
• Services re-embedded the rules
• Tests passed because behavior looked correct
• Audit questions failed because decision rationale was lost

The AI wasn’t wrong.
The SDLC system was incomplete.

What worked was enforcing 3C explicitly:
• Context persisted as shared, versioned SDLC memory
• Constraints became executable guardrails, not guidance
• Collaboration happened on a single execution surface shared by humans and agents

Enterprise AI succeeds only when all three Cs are present.
Miss one — and AI accelerates failure.

Why AI-assisted SDLC fails at scale: missing design-time authority

Afzal Shaikh — Thu, 09 Apr 2026 11:16:56 +0000

AI tools have made individual contributors faster.
They have not made enterprise delivery safer.

In a recent modernization program, we used AI for:

Requirement extraction from legacy code
Service decomposition suggestions
Test case generation

All worked — locally.

What failed was global consistency.

Example:
An architectural decision explicitly externalized eligibility logic for regulatory change.
That constraint existed in design documents.
It was not enforceable during AI-assisted development.

Six sprints later:

Generated services re-embedded the logic
Tests validated behaviour, not architectural intent
Audit required explanation that no longer existed

The issue wasn’t AI accuracy.
It was absence of design-time authority at runtime.

What corrected this was enforcing a system-level rule:

Architecture decisions became executable guardrails
AI agents operated inside those constraints
QE derived scenarios from the same decision lineage

At SDLC scale, intelligence without authority increases risk.
Deterministic execution under architect-defined guardrails reduces it.

From AI suggestions to deterministic SDLC execution: what actually works in enterprise programs

Afzal Shaikh — Wed, 08 Apr 2026 08:40:17 +0000

Most AI usage in SDLC today focuses on accelerating tasks:
generate requirements, draft designs, write code, create tests.

In enterprise programs, this breaks quickly.

Here’s a concrete example.

During modernization, a legacy onboarding flow had ~120 implicit rules
spread across COBOL programs, PDFs, and tribal knowledge.
Using AI prompts alone helped extract fragments — but outputs changed
every run and couldn’t be trusted downstream.

What actually worked was a deterministic SDLC pattern:

Freeze extracted requirements into a stable, versioned knowledge graph
Bind architecture decisions explicitly to those requirements
Generate development guardrails (not just code)
Drive QE coverage deterministically from decision + rule lineage

Once SDLC intelligence carried memory across phases,
teams stopped re‑discovering the same logic repeatedly.

AI adds value in SDLC only when:

Outputs are reproducible
Decisions are traceable
QE validates intent, not just execution

Speed without determinism increases risk.
Controlled intelligence reduces it.

sdlc #ai #softwarearchitecture #qualityengineering #enterprisedev

Deterministic AI is becoming mandatory for enterprise SDLC — not optional

Afzal Shaikh — Tue, 07 Apr 2026 07:13:06 +0000

Most GenAI implementations in SDLC are probabilistic by design.
That works for brainstorming — it fails in enterprise delivery.

In real programs, SDLC requires:

Consistent outputs across runs
Traceability from requirements → design → code → tests
Audit‑ready decisions
Repeatable QE coverage (functional + non‑functional)

Randomness helps creativity.
SDLC needs determinism.

We’re seeing a shift from “AI assistants” to deterministic intelligence embedded directly into SDLC workflows.

How are teams balancing speed vs determinism in AI‑led engineering?

These patterns are something we’re implementing in deterministic SDLC platforms like SASVA 4.0.

ai #sdlc #softwarearchitecture #qualityengineering #devtools