An AI SDLC workflow defines stages, owners and gates for every change, ships to agents as skills, and is versioned and measured so AI adoption compounds.


An AI SDLC workflow is an explicit, shared definition of how a change moves from idea to production when people, coding agents and tools all do part of the work. You design one by naming the stages, assigning each step to its best owner, putting repeatable gates between stages, shipping that definition into every agent as skills, and then versioning and measuring it like any other system. That is what turns AI adoption from improvisation at scale into something that compounds across the org.
This is part 4 of 5 in our series on the AI SDLC. Earlier parts looked at what coding agents are doing to your codebase and how to measure it. This part is about the thing those measurements eventually point at: the process itself.
Walk through almost any engineering team today and you will find that every developer runs a private process inside their own agent. One asks the agent for a plan, reviews it, then builds. Another goes straight to code and iterates until the tests pass. One runs a security scan before opening the pull request; another forgets, and the reviewer does not notice because the diff is 1,400 lines of plausible code. Hand-offs between product, design and engineering happen in chat threads and spreadsheets.
Some of those private processes are excellent. The problem is that nobody can see them. Leaders see output (pull requests merged, tickets closed, tokens spent) but not process. So when the ledger service starts accumulating rework, nobody can say whether it is because one team skips planning, because agent-written tests are shallow, or because the review step quietly became a rubber stamp. You cannot tell which way of working actually ships good software, which means you cannot spread it.
Improvisation at scale does not compound. Every good habit stays with the person who has it.
Three properties separate a workflow from a wiki page. It is executable: agents and tools follow it directly rather than relying on someone remembering it. It is observable: each stage leaves a trace you can measure. And it is versioned: when you change it, you know which changes ran under which version.
Most teams can start with five stages. The names matter less than agreeing on what "done" means for each, because that definition becomes the gate.
Not every change needs every stage at full weight. A one-line bug fix can collapse plan and design into a sentence. That is fine, as long as the collapse is a property of the workflow type and not a decision each developer makes privately.
The core design decision is giving each step to whoever does it best. A useful default split:
Here is how that might look for a feature such as adding multi-currency support to checkout, which touches the ledger service:
Notice that the two places where human judgment is mandatory (design sign-off and money-logic review) are named in advance, not left to whoever picks up the ticket.
A gate is the check a change must pass to move to the next stage. Gates are where workflows succeed or quietly fail. A good gate has four properties:
Prefer gates that a tool can evaluate, and reserve human gates for decisions that genuinely need judgment. When a human gate is approved within seconds every time, treat that as a signal: either it should be automated or it is not doing anything.
A workflow that lives on a wiki is read once during onboarding and then forgotten. Developers do not open a wiki page in the middle of a session with an agent. The process has to be where the work happens.
Most coding agents now support some form of skills: packaged instructions, templates and scripts the agent loads when a task matches. Turn each stage of the workflow into a skill. A planning skill tells the agent what a complete plan contains and refuses to move on without acceptance criteria. A build skill tells it to keep pull requests scoped to the plan and to write tests first for money-handling code. A validate skill tells it which scans to run and how to summarize results for the reviewer.
This way the process travels with the tool. A new hire on their first day gets the same planning discipline as your best senior engineer, because the agent carries it.
Version the workflow like code. Every change that runs through it should record which workflow version it ran under. Then measure each stage separately rather than only the end-to-end number:
With that in place you can run real experiments. Change one thing (for example, require the planning agent to list affected services explicitly) and watch what moves over the next few weeks. Did rework from review drop? Did plan-stage time grow? Change two things at once and you will not know which one helped.
Once the process is explicit, you can improve it. Until then you are only improving individuals.
Do not start with an org-wide mandate. Start small and earn the right to expand:
Sparkey lets you define agentic SDLC workflows as stages with an owner for each step and gates between stages, and ship them to coding agents as skills. Because Lens links agent sessions to the pull requests they produce, we can measure each stage per workflow version: time, rework, gate outcomes and the downstream quality signals covered earlier in this series. That makes one-change-at-a-time experiments practical rather than anecdotal.
The teams pulling ahead with AI do not have the most tools. They decided how work flows, made it explicit, and kept improving it. In part 5, "What Is an Engineering Brain? A Knowledge Graph for AI Agents", we look at the engineering brain: the shared context that lets agents and people follow a workflow with the full history of the system in view.
It is a versioned definition of how a type of change moves through stages such as plan, design, build, validate and deploy. Each step has a named owner (a person, an agent or a tool), and each stage ends in a gate that runs the same way every time. Unlike a wiki process, it is executable by agents and measurable per stage.
Agents are well suited to generation and first-pass review: drafting plans and designs from a brief, writing code and tests, and flagging issues before a human reviews. People should keep intent, trade-offs and approval of irreversible or high-risk decisions. Deterministic checks belong to tools.
A gate is the check a change must pass to move from one stage to the next, such as an approved plan with acceptance criteria or a passing security scan. Good gates are consistent, specific, recorded and cheap relative to the risk they prevent. Overrides should be allowed but always visible.
Developers do not consult documentation mid-session, but their agents load skills automatically when a task matches. Packaging each stage as a skill means the process travels with the tool. Updating the skill updates the process for everyone at once.
Record which workflow version each change ran under, then compare cycle time per stage, rework per stage, gate pass and override rates, and downstream outcomes like reverts and change failures. Change one thing at a time so any movement can be attributed to it.
Start with one team and one workflow type, such as bug fixes. Document the current process as a baseline, define a minimal workflow with owners and gates, ship it as skills, and measure for a few weeks before changing anything else or expanding to other teams.

Sparkey shows how AI coding tools and agents are changing your teams, your code and your costs.