AI in the SDLC becomes genuinely interesting the moment an assistant stops suggesting and starts participating in the working loop as an executor.
The chapter shows how agent workflows reshape development tooling through protocols, access control, evaluation, and the practical limits of adoption inside a real team.
In design reviews, it helps you discuss autonomy boundaries, the trust model, and AI's place in engineering work without drifting into vague talk about the future of software development.
Practical value of this chapter
SDLC evolution
The chapter helps you show how AI moves from suggestion mode into active participation inside the development loop.
Autonomy boundaries
It is a practical way to discuss which actions an agent can be trusted with and where a human must remain in the loop.
Measured impact
The material shows why SDLC AI cannot be discussed through speed alone without quality, safety, and rollback cost.
Interview material
It is a strong case for discussing AI in the SDLC through protocols, access control, evaluation, and organizational constraints.
AI in SDLC: the path from assistants to agents by Alexander Polomodov
An extended talk about what changes once a team moves from AI assistants to agent workflows: where the line of trust in an agent runs, and how development processes get rebuilt around it — the approach the speaker calls Software Engineering 3.0.
Source
Telegram: Book Cube
The main post for the report with the structure of topics and the context of the speech.
Key trajectory
Assistants: copilot mode in the IDE
The first wave never left the editor: autocomplete, template generation, faster local development. The engineer was still the only one who carried a change through to a result.
Shift to agents
An agent works against a goal: it plans steps, invokes tools, operates on the repository, and returns a measurable result.
From standalone tool to platform
A single agent hits a ceiling without shared footing: it needs common protocols and infrastructure — context, security, audit, access control, and standardized integrations. Otherwise every connection has to be rebuilt from scratch.
Software Engineering 3.0
The SDLC shifts toward a model where a human sets intent, an agent executes, and a human validates the result before deciding whether to release changes.
Agent scenarios in platform practice
- Agent mode in product development, demonstrated on the “5 Letters” game case.
- Agent in a Python notebook for data work and faster analytical loops.
- Agent for testing and test-scenario generation with an emphasis on risky cases.
- Agent for code review: finding defects, code smells, and standards violations.
- Vulnerability-detection agent (safeliner) inside a secure SDLC loop.
Related chapter
Programming Meanings by Alexey Gusakov (CTO Yandex)
The same bet from another angle: intent-driven development and connected product/ML cycles.
Infrastructure and economic drivers
Economics of agency
A multi-step agent burns through many tokens, and that used to be too expensive. Falling compute costs and stronger foundation models moved the line: what did not pay off before is now practical.
Integration protocols
Without a shared standard, every agent-to-tool link turns into a separate integration. MCP and A2A cut that cost and simplify the orchestration of agent-to-tool and agent-to-agent chains.
Tool base
The general-purpose IDE plugin is giving way to specialized agents and CLI-based workflows — for example Claude Code and OpenAI Codex. The working loop moves from the editor into the terminal and the pipeline.
Management and regulation of agency
- An agent-governance model starts with explicit boundaries: what level of autonomy is allowed and where the decision stays with a human.
- Critical actions — security work, production configurations, migrations — require a human in the loop and traceable approval: here the cost of a mistake outweighs the gain in speed.
- Speed without a second axis is misleading. Result evaluation keeps quality next to it: defects, vulnerabilities, and rollback cost.
- Agent metrics stop being a separate dashboard and become part of the engineering platform and the management loop around it.
Related topic
Observability & Monitoring Design
Where the signal for evaluating agents comes from: a measurable feedback loop for production platforms.
Measuring the effectiveness of assistants and agents
Productivity
Lead time, cycle time, throughput, time to first pull request
Quality
Defect escape rate, rework rate, flaky tests, review findings
Reliability and safety
Security findings, policy violations, rollback rate, incident impact
Adoption
DAU/WAU, retention, share of tasks handled with agents, reasons for opting out
Links and materials
YouTube: AI in SDLC
Full recording of the talk.
VK Video
An alternative platform for viewing the episode.
Telegram: main post
Talk structure, links, and the main takeaways.
Previous report
An introductory framework for integrating AI into development processes.
Selection of sources (part 1)
A curated set of links on agents, case studies, and engineering practices.
Selection of sources (part 2)
Continued materials for in-depth study.
AI survey in development
Study of the influence of AI on software engineering in Russia.
Related chapters
- AI Engineering - What you still have to build once an agent ships to production: lifecycle, risks, quality loops, and operations.
- Prompt Engineering for LLMs - How to set intent and constraints so an agent workflow behaves predictably.
- Programming Meanings by Alexey Gusakov (CTO Yandex) - A complementary intent-driven view of product and ML development cycles.
- Observability & Monitoring Design - Metrics, alerting, and feedback loops for AI features in production.
- Testing Distributed Systems - What to check an agent's changes against: reliability validation and regression control in complex systems.