By Illia Sokolov, Senior Technology Fellow at ABCloudz
Generative AI already helps developers write code faster. But using it primarily through a chat window leaves much of that potential unused.
The model often lacks enough project context to solve a task properly. The developer still has to explain the problem, copy information back and forth, interpret the response, and manually connect AI output to the rest of the development process.
Chat-based AI can help with individual questions, but it remains disconnected from much of the context, standards, and workflow that make software delivery reliable.
We are moving toward a different model: specialized AI agents working inside the software development lifecycle alongside business analysts, developers, QA engineers, DevOps engineers, and other delivery roles.
Build an agentic development environment that can accelerate work across the SDLC while keeping company standards, project context, validation loops, and human approval in the process.
Keep reusable behavior separate from project context
Agents and skills are only half of the system.
The other half is context.
If every agent has to rediscover company standards, architecture rules, project conventions, API contracts, and business terminology every time it receives a task, the organization loses much of the benefit of using agents in the first place.
We therefore use two different knowledge layers.
- Company-wide repositories describe how we want work to be done.
- Project-specific repositories describe what is true in this particular project.
Keep reusable agent behavior and project-specific knowledge separate. The same skill can enforce organization-wide standards across many projects while adapting its output to the architecture, stack, and rules of the project where it runs.
A developer can therefore invoke the same reusable skill in two different projects and get output that follows the same engineering standards but respects different local technologies and constraints.
Turn raw business input into project-aware requirements
The same model can be applied before development starts. A business analyst may begin with something very unstructured: meeting notes, an email, a transcript, or another piece of customer input. Instead of asking one generic chatbot to turn that text into a user story, the work can be separated into specialized steps.
The important difference is that these agents do not work from the meeting notes alone. They can use company templates and BA standards together with the project's glossary, personas, product rules, historical tickets, and other local context.
Unstructured customer input can be turned into requirements that follow a standard format while still being checked against the actual rules and terminology of the project.
Make test generation a feedback loop, not a one-shot prompt
QA follows the same pattern. A feature ticket such as "Automate Checkout Flow" can become the input to a local swarm of specialized agents. But generating a test script is not enough. The useful workflow is the loop around that generation.
The useful unit of AI-assisted QA is not generated test code. It is a loop that plans the test, generates what it needs, runs the result, detects failures, and sends corrections back before the test is accepted.
For example, if a UI change breaks a selector, a local validation agent can identify the new DOM selector and repair the test instead of treating the generated script as finished output.
Put planning, coding, testing, and validation into the same development loop
The developer workflow uses a similar pattern. A ticket does not go directly to an agent with a generic instruction such as "write the code." The task first gets planned against the architecture. Code is then produced, tests are generated, and the result is validated locally.
This is the part of the flow we already use. The right side of the original diagram shows where we want the workflow to continue in the future after the code reaches CI/CD.
Implementation can move through planning, generation, testing, and local validation as one repeatable loop instead of treating AI code generation as the end of the task.
The target is an agentic SDLC, not one universal agent
The same architecture can eventually connect work across roles. A customer meeting or requirement can enter the BA workflow. Structured requirements can become development tasks. Development agents can plan, implement, test, and validate them. QA agents can create and maintain automation. CI/CD agents can review results, analyze failures, and eventually help create and triage defects.
That is the SDLC we are working toward.
Current AI models are not reliable enough to make every decision correctly on the first attempt. Agentic development therefore depends on feedback loops, validation, shared context, and explicit human approval points rather than unrestricted autonomy.
Some parts of the north-state diagrams are already in use. Others still represent the direction we are building toward.
The distinction matters.
The objective is not to remove people from software delivery. It is to move more repeatable execution into controlled agent workflows while people continue to own the decisions and approvals that require engineering judgment.
We are already using this approach on real software
This is not only an architecture exercise. We have already used agentic development to build software internally.
Our Integration Knowledge Hub and CRM were developed through agent workflows without developers manually writing the application code.
We are also applying the same development model to another active project. The demo I recently showed internally was produced through the agentic workflow as well, without me manually writing the implementation code.
The agents do not make the process magically correct on the first attempt. What changes is where the developer spends time. Instead of manually producing every line, the developer increasingly orchestrates planning, context, validation, feedback loops, and approval.
The scalable part of agentic development is not simply giving a stronger model a larger task. It is building a system around the model that supplies the right standards and project context, divides work into specialized roles, validates the output, and knows where a human still needs to decide.
Bring agentic AI into your development process
Agentic AI can support much more than code generation.
The same principles can be applied across business analysis, development, QA, review, security validation, CI/CD, and project knowledge management.
Whether you are building a new application or introducing AI into an existing engineering organization, ABCloudz can help design the agents, reusable skills, project context, validation loops, and governance around the way your team actually develops software.
