For the last few years, the dominant mental model for AI in software engineering has been simple: a developer writes code with an assistant. The developer asks a question, receives a suggestion, accepts or rejects it, and continues working.
That model is giving way to something more consequential. AI systems are beginning to participate in workflows that span planning, implementation, testing, review, documentation and operational investigation. The shift is not simply from autocomplete to a more capable chatbot. It is from assistance at the point of coding to orchestration across the software delivery lifecycle.
From a coding assistant to a delivery system
A coding assistant is usually bounded by the developer’s immediate task. An agentic workflow can take a goal, gather context, propose a plan, use tools, make changes and return evidence of what it did. Multiple agents may specialise in different parts of the work.
Consider a feature request. One agent could help clarify the problem and draft acceptance criteria. Another could inspect the repository and identify likely components. A coding agent could implement a bounded change and run tests. A separate reviewer could examine the diff for regressions, missing cases and security concerns. A human engineer remains accountable for the decisions and the release.
This is not a claim that every team needs a fleet of autonomous agents. It is a useful design pattern for work that is repeatable, well-scoped and supported by reliable feedback.
The hard problems move up the stack
When code generation becomes cheaper, the constraints around it become more visible. Teams need to manage shared context, conflicting edits, tool permissions, task boundaries, evaluation, observability and recovery. A system that can produce a plausible patch is not necessarily a system that can safely deliver a production change.
- Context: Can the agent find the relevant architecture, conventions, dependencies and decisions?
- Decomposition: Can the work be divided into tasks with clear ownership and acceptance criteria?
- Verification: Does the workflow produce test results and reviewable evidence, rather than asking humans to trust a confident summary?
- Control: Are permissions limited to what the task requires, with approval gates for consequential actions?
- Recovery: Can the team stop work, revert changes and understand what happened when an agent fails?
Design the workflow before scaling the agents
My recommendation is to start with one narrow workflow rather than trying to automate the entire SDLC. Good candidates include dependency-update triage, test generation for a well-understood component, documentation updates after a change, or investigating a known class of CI failure.
Define the starting conditions, expected output, tools the agent may use, quality checks and the point at which a person must take over. Establish a baseline for cycle time, review effort, defects and rework. Then compare like-for-like work after introducing the agent.
Only expand autonomy when the evidence supports it. A task that is safe to automate in a test repository may not be safe in a production service handling customer data. The permission model should reflect the consequences of failure.
The engineering manager’s new responsibility
Agentic engineering changes the management problem. Leaders will spend less time coordinating every routine hand-off and more time designing the environment in which humans and agents can do dependable work. That includes making organisational knowledge accessible, clarifying decision rights, setting quality standards and developing engineers’ ability to evaluate machine-generated work.
The competitive advantage will not come from having the largest number of agents or the newest model. It will come from building a delivery system that combines machine speed with human judgement, clear accountability and strong feedback loops.
Where to begin
- Choose one frequent, bounded engineering workflow.
- Document the current process and establish a measurable baseline.
- Give the agent the minimum context and permissions it needs.
- Require observable evidence: changed files, test results, decisions and known limitations.
- Review outcomes after a fixed period and decide whether to scale, change or stop.
AI-assisted coding made it easier to produce code. Agentic engineering asks a more interesting question: how do we redesign the system around that capability so that better software reaches users sooner, without sacrificing reliability?