Rethinking Engineering Delivery in the Age of Agentic AI

The SEAP Technology & Innovation Pillar conducted an in-person workshop on “Rethinking Engineering Delivery in the Age of Agentic AI”, focused on one of the most important shifts currently reshaping software engineering: the movement from AI-assisted development to agentic engineering delivery.

The session was led by Sameer Mardhekar, Prasad Chitale, and Swati Deodhar, and brought together technology leaders, product leaders, engineering practitioners, and SEAP members for a deeply practical discussion on how Agentic AI is changing the way software is designed, built, reviewed, tested, governed, and scaled.

This was not a generic AI awareness session. The workshop was deliberately focused on the software engineering lifecycle, particularly for IT services, product engineering, GCCs, startups, and enterprise technology teams.

From AI-Assisted Coding to Agentic Engineering

The session opened with the evolution of software development over the last few years.

Traditional development relied heavily on manual coding, handcrafted logic, code snippets, and developer-led implementation. This was followed by AI-assisted development, where tools such as GitHub Copilot helped developers write snippets, improve code, generate boilerplate, and accelerate individual productivity.

The current phase is more significant. Agentic AI tools such as Claude Code, Codex, Antigravity, and similar platforms are beginning to move beyond assistance. They are taking on larger parts of the development workflow, including interpreting requirements, designing components, generating code, identifying tasks, and completing implementation steps.

The key message was clear: AI tools are no longer only helping engineers do the work. Increasingly, they are doing meaningful parts of the work.

This creates a major opportunity for speed, productivity, and experimentation. It also introduces serious challenges around quality, architecture, security, accountability, governance, and maintainability.

Understanding Vibe Coding

A major part of the discussion focused on Vibe Coding, where developers describe intent in natural language and allow AI systems to generate working code.

Sameer Mardhekar, Prasad Chitale, and Swati Deodhar demonstrated how a simple invoice management application could be built using Claude Code. The prompt included users, customers, invoices, payments, reports, database entities, and expected functionality. Claude Code then generated the backend, frontend, database schema, UI structure, reports, payment workflows, and additional features such as automated reminder emails.

The demonstration showed the power of intent-led development. A working application could be created rapidly with limited manual coding.

However, the discussion was balanced. Vibe Coding works well for prototypes, MVPs, isolated features, and early-stage experimentation. It becomes fragile when used for complex, enterprise-grade, multi-developer, or brownfield systems.

Why Vibe Coding Starts Failing at Scale

The workshop highlighted three major challenges that appear when Vibe Coding is applied at scale.

Context loss: As conversations with AI agents grow longer, earlier requirements, constraints, and design decisions may get diluted or lost.

Assumption drift: When the AI does not have enough clarity, it starts making assumptions. These assumptions may not match business intent, architecture standards, security requirements, or product expectations.

Pattern violations: Generated code may ignore established coding standards, API boundaries, architectural rules, database access patterns, or enterprise conventions.

These issues do not happen in isolation. They amplify each other. Over multiple iterations, code may continue to compile, but the underlying system quality can decline significantly.

This was one of the most important points of the session: uncontrolled AI speed can increase delivery risk if it is not supported by clear specifications, constraints, architecture guardrails, review discipline, and governance.

Vibe Design and AI-Generated Interfaces

The session also covered the emerging area of Vibe Design through tools such as Stitch. Using the same invoice application prompt, the tool generated professional UI designs and mobile screens.

This sparked a useful discussion on how AI can help engineers, architects, and product teams visualize applications faster. Vibe Design can be valuable for early ideation, rapid prototyping, requirement clarification, and stakeholder alignment.

At the same time, the speakers emphasized that AI-generated design is still a starting point. It must be reviewed for usability, consistency, accessibility, customer context, brand alignment, and long-term product fit.

Spec-Driven Development: The Governance Backbone

The core theme of the workshop was Spec-Driven Development, or SDD.

The central idea is that AI agents need a complete and structured picture upfront. They need to know what exists, what needs to be built, what must not be built, what constraints must be followed, what architecture patterns must be respected, and how success will be validated.

In this model, specifications become the primary engineering artifact. Code increasingly becomes a generated byproduct of clear business intent, technical constraints, and validation criteria.

The speakers demonstrated how tools such as Spec Kit help create a structured flow from project constitution to product specifications, technical design, implementation tasks, parallel workstreams, and eventual code generation.

This approach reduces random prompting and endless iteration. It creates persistent context, explicit constraints, architecture documentation, testing expectations, and implementation boundaries.

The broader takeaway was clear: for enterprises, Spec-Driven Development can become the governance backbone for scaling Agentic AI responsibly.

The Changing Role of Engineers

One of the strongest discussions in the workshop was around the future role of engineers.

The conclusion was pragmatic: engineering jobs are not disappearing, but they are recomposing.

Engineers will move from writing large volumes of code to specifying intent, orchestrating agents, validating outputs, reviewing behavior, managing constraints, and ensuring alignment with architecture and business outcomes.

Code review will evolve into output review and behavioral review. Estimating coding effort will shift toward estimating verification effort. Tribal knowledge will need to be codified into specifications, architecture guidelines, reusable prompts, governance rules, and agent-readable documentation.

This has major implications for engineering leadership, talent development, hiring, performance management, and training. Junior engineers will need deliberate mentoring so that AI assistance does not lead to foundational skill gaps. Senior engineers will need to become stronger at systems thinking, specification quality, agent orchestration, and governance.

New Metrics for AI-Assisted Engineering

The session also challenged traditional engineering metrics.

Lines of code, pull request count, story points, and sprint velocity may become less meaningful in an environment where agents generate large volumes of code quickly.

More relevant metrics may include time from intent to working software, verification coverage, rework rate after agent output, context quality, documentation readiness, architecture compliance, and the ability of an AI agent to work effectively from the available specifications.

The bottleneck is shifting. In the agentic era, the constraint is not always code generation. It is verification, judgment, governance, and decision quality.

Risks Leaders Must Address

The workshop surfaced several risks that organizations must address before scaling Agentic AI across delivery teams.

Verification bottleneck: AI agents can generate code faster than humans can review it.

Skill atrophy: Junior engineers may not develop foundational engineering intuition if they rely too heavily on AI-generated output.

Hallucination at scale: Code can look correct, compile successfully, and still miss the real intent.

Accountability gaps: Teams must clearly define who owns defects, design failures, and production issues when AI agents generate significant portions of the code.

Security and IP concerns: Organizations must make deliberate choices around enterprise tools, contracts, local models, data exposure, and usage policies.

The “looks done” trap: AI-generated code may pass basic tests but still fail to meet business expectations.

These risks are manageable, but only if organizations adopt Agentic AI with discipline.

Key Takeaways

The workshop delivered several practical takeaways for technology leaders.

Agentic AI is a delivery model shift, not merely a tooling upgrade.

Vibe Coding is valuable for experimentation, but enterprise-scale adoption requires specifications, constraints, architecture guardrails, testing discipline, and governance.

Spec-Driven Development can help organizations reduce context loss, assumption drift, and pattern violations.

Engineers will increasingly work as intent specifiers, agent orchestrators, reviewers, and governance owners.

Verification, architecture quality, documentation maturity, and human judgment will define success.

Organizations that adopt AI without structure may create faster chaos. Organizations that combine AI speed with engineering discipline can create a sustainable competitive advantage.

SEAP’s Role in Enabling Future-Ready Technology Leadership

This workshop strongly aligns with SEAP’s Technology & Innovation Pillar theme of Innovation, Inclusion & Impact.

It supported innovation by exposing the ecosystem to emerging engineering models.

It supported inclusion by bringing together industry leaders, practitioners, startups, and technology professionals for an open exchange of ideas.

It created impact by converting a fast-moving technology trend into practical insights that organizations can apply in real delivery environments.

SEAP will continue to create such platforms for Pune’s technology ecosystem, enabling leaders and practitioners to learn, debate, experiment, and build responsibly.

The future of engineering will not be defined by AI replacing developers. It will be defined by organizations that learn how to combine human judgment, structured specifications, responsible governance, and AI-led execution.

That future is already taking shape.