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.

The Death of TDD: GenAI Killed It

 Test-Driven Development (TDD) told us:

·   Write tests first
·    Write code to pass those tests
·    Repeat

That made sense — until GenAI showed up.

Tools like GitHub Copilot, CodeWhisperer, and Replit Ghostwriter flipped the workflow:

·         Write a prompt
·         GenAI writes the code
·         Then it writes the tests

TDD’s “Test First” is officially dead.

The New Reality

1.      Code First
Dev writes a prompt.
GenAI writes the code.
Dev’s job? Understand business logic + design. Not boilerplate.

2.      Tests Later
GenAI generates unit tests based on specs. No test scaffolding up front. Just clean, auto-generated coverage.

What We Gain

·         Blazing productivity – code + tests in minutes
·         Better quality – GenAI learns fast
·         Lower technical barrier – business-savvy folks + prompt mastery = working software

What We Risk

·         Devs may stop optimizing – “AI will fix it” mindset
·         Job loss is real – unless Jevons Paradox bails us out

What Might Stay Flat

·         Business Analysts may lead GenAI-powered dev teams, with a few tech wizards handling edge cases. 
·         Low-code/no-code platforms? Obsolete soon

Final Take

GenAI isn't improving TDD. It's replacing it.
GenAI isn’t tweaking TDD—it’s obliterating it. The entire SDLC is being gutted and rebuilt. TDD’s just collateral damage. Adapt or get left behind.

Curious how your team should evolve? Let’s talk.

Is Contemporary AI a Mature Engineering Discipline?

 

At a recent industry meetup, a thought-provoking question emerged: Has Artificial Intelligence (AI) evolved into a mature engineering discipline? The discussion was lively but largely focused on AI in isolation. That conversation stuck with me, prompting a deeper dive—not just into AI, but into how engineering disciplines as a whole mature over time.

As an electronics engineer by education and a software professional by trade, I’ve had the privilege of witnessing the evolution of two of the most impactful fields of the last century. Exploring their journeys offers valuable context for assessing where AI stands today.

Electronics Engineering: From Breadboards to Modular Mastery

The early days of Electronics Engineering involved manually designing circuits on paper, followed by prototyping on breadboards using discrete components—resistors, capacitors, diodes, and transistors. Once a design was validated, it was implemented on a fabricated Printed Circuit Board (PCB) for practical use.

The advent of Integrated Circuits (ICs) shifted the focus away from discrete components to chip-based solutions, enabling the development of more complex and compact devices. With the introduction of electronic design automation (EDA) software, breadboards became obsolete. Engineers could now design and simulate circuits virtually, while innovations in PCB manufacturing allowed for multilayer, high-density layouts, driving massive growth in the electronics industry.

As circuit complexity increased, the repairability of boards diminished. Faulty boards were more cost-effective to replace than repair, giving rise to a module-based approach where entire subassemblies—power supplies, heatsinks, sensors—were treated as replaceable units. This replaceability, coupled with the establishment of standardized design processes and professional certifications, reflects the discipline's maturity.

This evolution from component-level design to modular systems is one axis of engineering maturity. Another is the educational background required for practitioners. Initially, expertise in electronics demanded a PhD-level understanding. Today, a broad spectrum of professionals—from electronics engineers and science graduates to high school hobbyists—can contribute meaningfully to the field.

Software Engineering: From Binary to Low-Code

Software Engineering has experienced a similarly dynamic journey. Early programming involved writing binary code, followed by assembly language. The development of the C programming language marked a turning point, unlocking higher-level programming languages such as COBOL, which ushered in increasing levels of abstraction and domain-specific specialization.

Today, we have dedicated languages for specific tasks: HTML, CSS, and JavaScript for front-end development; SQL for data manipulation; and many others. Libraries and frameworks—like Java’s Struts for web applications—further simplified the development of complex systems. The latest trend is toward low-code and no-code platforms, allowing users to configure applications through visual interfaces rather than writing traditional code.

Metrics in Software Engineering have also matured. Early measures focused on hardware utilization and code efficiency (e.g., Chidamber & Kemerer metrics), but contemporary metrics, such as those in the DORA framework, emphasize business impacts and user satisfaction.

 

Innovations in storage media from punched cards and magnetic tapes to floppy disks, hard drives (HSSs), and solid-state drives (SSDs) have further supported the field’s ability to handle larger instruction sets and data, reflecting its growing maturity and capacity to address societal needs.

On the education front, software engineering has democratized significantly. What once required a PhD is now accessible to computer science graduates, electrical engineers, general science graduates, and even self-taught individuals and high school students.

Contemporary AI: Powerful but Early in Its Journey

In contrast, contemporary AI remains in its early stages of development. The field demands a deep understanding of complex mathematical concepts—such as linear algebra, statistics, and optimization—alongside specialized programming skills in languages like Python and frameworks like TensorFlow or PyTorch. This high entry barrier mirrors the educational requirements of early Electronics and Software Engineering.

 

AI is characterized by rapid innovation, evidenced by the proliferation of research papers and the emergence of new standards, such as the Agent Name Service (ANS) and Model Context Protocol (MCP). Experimentation with novel hardware architectures and internal communication protocols (e.g. DeepEP by Deepseek) underscores the field’s dynamic nature. However, current metrics in AI remain narrowly focused on technical aspects, such as hardware utilization, code efficiency, and the accuracy or "truthfulness" of outputs, rather than broader business or societal impacts.

 

Significant challenges persist, including the need for explainable AI to ensure transparency in decision-making and the ethical implications of deploying AI systems. These factors, combined with the field’s reliance on cutting-edge expertise and its evolving foundations, suggest that contemporary AI has not yet reached the maturity of its engineering counterparts.

Conclusion

While contemporary AI has made remarkable strides, it has not yet achieved the maturity seen in Electronics Engineering or Software Engineering. Its dependence on advanced technical knowledge, the rapid pace of research, and the predominance of technical metrics all indicate a discipline still in its formative stages. By contrast, Electronics and Software Engineering have developed standardized practices, broadened educational accessibility, and shifted their focus to encompass broader impacts—hallmarks of mature engineering fields.

 

To advance AI toward maturity, the community must prioritize several key areas: investing in education and training programs to widen access, establishing industry-wide standards to stabilize practices, and reorienting metrics to measure societal and business value alongside technical performance. Only through such efforts can AI fully evolve into a robust and mature engineering discipline.