Blog · AI SDLC series

What Is an AI SDLC Workflow? A Framework That Compounds

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.

Elad Zalait
Elad ZalaitOctober 27, 20268 min read
Five connected stages labeled plan, design, build, validate and deploy, with a gate between each stage and owner icons for people, agents and tools

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.

Why buying AI tools is not an AI SDLC

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.

What is an AI SDLC workflow?

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.

How do you define the stages and what "done" means at each?

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.

  • Plan. Done when the intent is written down: the problem, the acceptance criteria, what is out of scope, and which services are affected.
  • Design. Done when the approach is chosen and the risky decisions are explicit: data model changes, API contracts, migration strategy, and anything that touches money, identity or permissions.
  • Build. Done when the change is implemented with tests, the diff is scoped to the plan, and the author (human or agent) can explain every file it touched.
  • Validate. Done when automated checks pass, a human has reviewed what matters, and the change behaves correctly in an environment that resembles production.
  • Deploy. Done when the change is live behind whatever safety mechanism fits (a flag, a canary, a staged rollout) and someone has confirmed the signals that would show it failing.

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.

Who should own each step: people, agents or tools?

The core design decision is giving each step to whoever does it best. A useful default split:

  • People own intent and judgment: deciding what to build, accepting trade-offs, approving risky designs, and making the final call on anything irreversible.
  • Agents own generation and first-pass review: drafting plans and designs from a brief, writing code and tests, summarizing diffs, and flagging likely issues before a human looks.
  • Tools own anything deterministic: security scans, linters, type checks, duplication detection, CI and deploy automation. If a rule can be checked mechanically, a tool should check it, every time.

Here is how that might look for a feature such as adding multi-currency support to checkout, which touches the ledger service:

  1. Plan, product manager (person): writes the intent and acceptance criteria, including which currencies, rounding rules and what happens to existing orders.
  2. Plan, planning agent: expands the brief into a task breakdown and lists affected services, open questions and edge cases; the tech lead approves.
  3. Design, design agent then tech lead: the agent drafts the schema change and conversion approach; the tech lead decides on storing amounts in minor units with an explicit currency code and signs off on the migration plan.
  4. Build, coding agent with an engineer directing: implements the change and tests in small pull requests; the engineer steers and edits the parts that touch the ledger.
  5. Validate, tools: CI, linters, a dependency and secrets scan, and a duplication check run on every pull request.
  6. Validate, review agent then engineer: the agent does first-pass review against the plan and flags drift; a second engineer reviews the money-handling logic line by line.
  7. Deploy, tools and on-call engineer: a staged rollout behind a flag, with the engineer confirming conversion error rates and ledger reconciliation before widening.

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.

What makes a good gate between stages?

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:

  • It runs the same way every time. Same checks, same thresholds, regardless of who wrote the change or how urgent it feels.
  • It checks something specific. "Plan reviewed" is vague. "Plan lists affected services and acceptance criteria, approved by the owning tech lead" is a gate.
  • It records a decision. Pass, fail or override, with who decided and why. Overrides are allowed; invisible overrides are not.
  • It is cheap relative to what it prevents. A gate that adds a day to every one-line fix will be bypassed, and then it is worse than no gate.

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.

How do you ship a workflow into coding agents?

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.

How do you measure and improve an AI SDLC workflow?

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:

  • Cycle time per stage. Where does a change actually wait? Teams often discover the bottleneck moved from build to review once agents started writing code.
  • Rework per stage. How often does a change bounce back, and from which gate? Frequent bounces from validate to build often mean the plan stage is too thin.
  • Gate pass rates and override rates. A gate that always passes is not informative. A gate that is overridden a third of the time is either wrong or ignored.
  • Downstream outcomes. Reverts, change failures and churn on code shipped under each workflow version.

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.

How do you roll out an AI SDLC workflow?

Do not start with an org-wide mandate. Start small and earn the right to expand:

  1. Pick one team that already uses coding agents heavily and wants more consistency.
  2. Pick one workflow type. Bug fixes are a good first choice: frequent, short and easy to compare. Features come next.
  3. Write down how the team works today, honestly, before changing anything. That is version 0 and your baseline.
  4. Define stages, owners and gates for that one type. Keep the first version minimal.
  5. Package each stage as a skill and make it the default in the team's agents.
  6. Measure per stage for a few weeks, then make one change and compare.
  7. Once the numbers hold up, publish the workflow as a template other teams can adopt and adapt.

Common anti-patterns

  • Wiki-only process. A beautiful diagram that no agent reads and no tool enforces. If the workflow is not executable, it is documentation, not a workflow.
  • Gates as theater. Approval steps that everyone clicks through, checklists ticked from memory, review requested and granted in the same minute. These add latency and false confidence.
  • Over-automating judgment. Letting an agent approve its own design or auto-merge changes to the ledger because the tests passed. Agents are good at first-pass review; accountability for irreversible decisions belongs to people.
  • One workflow for everything. Forcing a dependency bump through the same five heavyweight stages as a new payments feature. Different change types deserve different workflows.

Where Sparkey fits

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.

Frequently asked questions

What is an AI SDLC workflow?

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.

Which steps should coding agents own?

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.

What is a gate in an AI SDLC?

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.

Why ship workflows to agents as skills instead of documenting them?

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.

How do you measure whether a workflow change helped?

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.

Where should an organization start?

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.

Elad Zalait
Elad Zalait
CTO, Sparkey AI
Follow on LinkedIn
All articles

See your own AI SDLC, measured

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

Book a DemoCalculate Your ROI