Perspective on SaaS providers

 

The narrative that “AI will make SaaS obsolete” misses the real shift. AI isn’t replacing SaaS, it’s rewriting its economics. Let’s examine it in little bit detail.

• From Features to Outcomes: Traditional SaaS sold tools you operate. AI-native platforms deliver autonomous execution. Agents don’t just assist—they generate leads, draft outreach, optimize campaigns, and run workflows end-to-end. Value shifts from “what the software does” to “what it delivers.”.

•  Pricing Models Are Resetting: Per-seat licensing loses relevance when one AI agent replaces multiple users. Expect hybrid structures (subscription + usage + outcome-based) and tighter pressure on revenue predictability.

• Rise of AI-native competitors: There will be two classes of SaaS providers. Incumbents – tweaking the existing offerings to accommodate AI and new players – developing AI native systems from scratch. If incumbent do not overhaul SaaS architecture in big way, they may become glory of past.

•  The “Build In-House” Mirage: AI slashes dev costs, tempting mid-market teams to ditch vendors. But TCO, compliance, security, and ongoing maintenance will likely push many back to established SaaS ecosystems.
•  Consolidation & Verticalization: AI will compress “SaaS sprawl.” Horizontal platforms face margin pressure, while vertical/specialized providers with proprietary data and deep workflow integration will strengthen.
•  GTM Still Dominates Cost Structure: AI accelerates engineering, but sales, marketing, and enterprise trust-building remain the largest cost centers. Code is cheap. Distribution and adoption are hard.
•  Agent Reality Check: Non-deterministic outputs and evaluation complexity mean AI is currently a powerful automation layer—not a full replacement for mission-critical systems. Governance and quality control remain non-negotiable.

 In conclusion, large incumbents will survive, but “seat growth” will slow, pricing power will compress, and AI-native challengers will redefine categories. The new competitive moat isn’t features or code, it’s workflow ownership, domain expertise, and outcome accountability..

What do you think!!!

Some unexpected effects of using AI in software engineering

 

AI in software engineering hasn’t just made teams faster. It has changed behavior, incentives, and failure modes in ways most orgs didn’t anticipate. Some of these effects are beneficial; many are subtle and dangerous if unacknowledged.

Here are the unexpected ones that actually matter.

1. Code quality variance increases, not decreases

AI raises the average productivity but also widens the spread between good and bad outcomes.

• Good engineers use AI to explore, refactor, and reason
• Weak engineers use AI to ship code they don’t understand

Result:

• More code gets written
• Less code is truly owned
• Debugging costs shift downstream

Velocity goes up. Maintainability becomes bimodal.

2. Architectural debt accelerates faster than technical debt

AI is excellent at:

• Local correctness
• Pattern completion
• Incremental changes

It is bad at:

• Global coherence
• Long-term architectural intent
• Saying “don’t build this at all”

Teams discover later that:

• Interfaces multiplied
• Invariants drifted
• Systems “work” but feel brittle

AI doesn’t resist bad architecture. Humans must.

3. Junior engineers skip the struggle phase and pay later

AI short-circuits:

• Syntax errors
• Boilerplate learning
• Trial-and-error discovery

This feels great until engineers face:

• Production incidents
• Non-obvious race conditions
• Emergent system behavior

The missing piece isn’t knowledge; it’s intuition built through friction.

Without deliberate training design, AI produces engineers who can assemble systems but can’t reason about them under stress.

4. Review culture collapses unless explicitly redesigned

Traditional code review assumed:

• Humans wrote the code
• Reviewers could infer intent
• Mistakes were personal, not systemic

With AI:

• Intent is unclear
• Code looks “reasonable” even when wrong
• Reviewers hesitate to challenge the generated output

Many teams experience:

• Rubber-stamp approvals
• Superficial stylistic feedback
• Deep logic errors are slipping through

Code review must shift from syntax policing → assumption and invariant checking.

5. Documentation paradox: more code, less explanation

AI generates:

• Code faster than humans can explain
• Implementations without rationale

Unless enforced, teams end up with:

• Working systems
• No record of why decisions were made
• Fragile onboarding and change processes

Ironically, AI increases the value of human-written design docs, but teams often produce fewer of them.

6. Debugging becomes harder even as coding gets easier

AI handles happy paths well.

But when things break:

• The codebase is larger
• Fewer people understand it end-to-end
• Errors span generated and human-written logic

Engineers report:

• Longer time-to-root-cause
• More “I didn’t write this” moments
• Higher cognitive load during incidents

The work shifts from writing code to interpreting behavior.

7. Engineers optimize for prompting skill, not system understanding

Unexpected career effect:

• Some engineers become prompt specialists
• Others deepen system intuition

The risk:

• Prompt fluency can mask shallow understanding
• Teams reward speed over comprehension

Over time, this creates fragile organizations that are fast in normal times and slow during crises.

8. Organizational bottlenecks move, not disappear

AI removes coding as a constraint.

New bottlenecks appear in:

• Requirements clarity
• Decision-making
• Testing strategy
• Deployment and ownership

Teams discover the uncomfortable truth:

Coding was never the hard part.

AI exposes organizational dysfunction faster than it fixes it.

9. “Good enough” becomes the default, and excellence becomes rarer

Because AI produces plausible solutions quickly:

• Teams stop pushing for elegance
• Refactoring gets deprioritized
• “It works” beats “it’s right”

Excellence now requires intentional resistance to convenience.

The meta-effect (this is the real one)

AI doesn’t replace engineering skill.
It amplifies whatever skill or lack of it already exists.

In strong teams, AI compounds leverage.
In weak teams, it compounds chaos.

Practical takeaway for leaders and senior engineers

If you don’t explicitly redesign:

• Training
• Review standards
• Ownership models
• Architectural governance

AI will quietly degrade your engineering culture while making you feel productive.

Used well, AI turns engineers into system thinkers.
Used lazily, it turns teams into code factories with no intuition.

Software Development at dawn of AI

 

Contemporary software development process is fairly manual with sprinkles of automation. As our current technological landscape permits, automation is limited to repetitive and rule based tasks. The prime examples of existing automation are:

• Static Code analysis
• Behavior Driven Development (BDD) generating Behavior / Functional Tests from a rule bound acceptance criteria
• Auto execution of Unit Tests at each build
• Auto execution of Tests (pre-written as test script) after deployment in sub prod environments
• Auto deployment using CI/CD Pipeline
• Executing Regression test suit

All of the automation listed above have following characteristics:

• In each project/product development environment, deployment environments, availability of tool set, technical landscape, and product under consideration itself are unique, so act of creating automation is not automated;
• Automation is hand crafted by engineers; and
• Fragmented automation

Following areas of software development are not automated at all (or most of it):

• Requirement Management
• Technical Architecture and Design
• Technical Architecture and Design review (for ease in change, accuracy, efficiency & utilization of underlying resources, future proofing (sic!), compliance & regulatory requirements, security and performance requirements, policy compliance, and adhering to best practices)
• UX Design
• UX Design review (for usability, ease in change, accuracy, efficiency & utilization of underlying resources, future proofing (sic!), compliance & regulatory requirements, security and performance requirements, policy compliance, and adhering to best practices)
• Code writing (recently code generation is started gaining traction)
• Unit Tests writing
• Code and Unit Tests review (except for static code analysis)
• Writing Functional tests
• Executing Functional tests
• Writing Integration / End-to-End tests (except for Behavior tests under BDD regime)
• Executing Integration / End-to-End tests (
• Writing Performance / Load  tests
• Executing Performance / Load tests
• Writing Security tests
• Executing Security tests
• Technical Documentation (Most of the IDEs generate inline  documentation but at low level, not explaining Architecture and Design)
• Project Management (Agile, hybrid, waterfall)
• User Documentation (Training material)
• Automation of automatic tasks

With the arrival of GenAI and contemporary developments in machine learning a paradigm shift is taking root in code writing - usage of AI Assistants Agents (e.g.  Copilot from GitHub) for code generation within IDE.  Code generation by AI tools has started acting as fellow developer who can write code from well-crafted prompts.

The tool chain for software development tasks are fragmented and require highly specialized persons and in large number due to

• Complexities of underlying business requirements;  
• Available platforms, tools & technologies;
• Dependency on underlying infrastructure; and
• Inter-dependencies of above.

The next level of automation in software development will be a framework of interconnected AI Agents, AI Assistants, and AI bots. This automation will drastically change software development team composition and put pressure on team’s skill set.

A fully AI immersed software development framework will have collaborative AI Agents, Assistants and Bots:

• Collating and  compiling evolving requirements;
• Developing & maintaining Technical Architecture & Design and continuously reviewing it;
• Developing and maintaining UX Design and continuously reviewing it;
• Generating Code and unit testing in accordance with agreed upon Technical Architecture & Design, UX Design, and Requirements;
• Continuous reviewing the generated code (and unit tests) and giving feedback to code generation AI toolset ;
• Generating functional & non-functional test cases and test scripts for automatic execution;
• Refactoring the Technical Architecture & Design and code to incorporate results of testing and evolving requirements;
• Configuring CI/CD pipeline and deploying it; and in the last;
• Deploying the code in non-production environment; and
• Deploying the code in production environment and validating it.

The envisioned AI immersed software development will have following characteristics:

• Software development team will consists of two types of team members – Human and AI members
• Each Human team member will have at least one companion – specialized AI Agent or Assistant
• Rule based automations will be taken-care by AI Bots
• Human team members will focus on human interactions (e.g. eliciting requirements)
• Human team members will also focus on jobs which does not have table-top environment (e.g. Defining Technical Architecture, defining UX Design, defining rules for AI Bots, etc.)
• Majority of Human team members will be performing requirement elicitation, defining & reviewing Technical Architecture, defining & reviewing UX Design, Rules for CI/CD pipeline, validation in production environment, deploying AI tool set (Agents, Assistants, and Bots)
• TDD is fading and soon be past
• BDD will drastically change to accommodate emerging AI toolset
• A new SDLC will emerge where different phases will merge into each other (not like Agile) and some will fade to give way to new ones
• A new team structure is emerging which is Business/System Analyst, Sr. Technical Developer, and Sr. Quality Analyst heavy who can elicit requirements and provide oversight over AI toolset
• Project Management (whether Agile, Hybrid or Waterfall) will change drastically. A new way of managing SDLC cycle is emerging to accommodate new SDLC and team structure  

 In future articles, I will be exploring different phases of SDLC, team structure, software development methodologies, and metrics evolving in response of AI overtake of software development.