Agentic SDLC
The full agentic software development lifecycle — plan/grill, spec, tickets, implement, review — composed from discrete AI skills or agents rather than a single generate step.
Also known as: agentic SDLC, software development lifecycle, development lifecycle, grill to spec to tickets, spec to tickets, coding lifecycle
Part of: Agentic Engineering
Documents (9)
- Agent-First Engineering: 9 Playbook Tips for a Zero-Human-Code Future Avi Pilcer · 2026-10-08 Reader 🖥️
A codebase and its surrounding processes must be deliberately re-engineered — minimal, pointer-style instruction files, plans and architecture decisions checked in as versioned markdown, boring/predictable tooling, and scheduled background agents for cleanup and doc-sync — to remain legible and non-degrading as the volume of agent-written code grows toward (the author claims) zero human-written code; the engineer's job shifts from writing code to designing this environment. - Cloudflare Introduces the Agent Development Lifecycle to Replace Traditional SDLC Olimpiu Pop · 2026-09-21 source ↗ Reader 🖥️
Because AI models have made code generation fast, the bottleneck in software delivery has shifted downstream to testing, deployment, and maintenance, so Cloudflare argues the entire SDLC must be rebuilt as an event-driven 'Agent Development Lifecycle' — with Workflows as the orchestration primitive, OpenTelemetry-style observability into agent reasoning, and machine-speed security enforcement (short-lived scoped credentials plus a dynamically-narrowing 'Trust Ratchet') replacing human-paced review gates. - Inside a Software Factory Paul Iusztin · 2026-09-04 Reader 🖥️
A 'software factory' — a human-operated automated pipeline of eight SDLC stages over a shared context layer — is the right unit of analysis for disciplined AI-assisted development because it locates humans precisely at brainstorming, planning, and final review while agents execute everything between, and the engineering skill lies not in maximizing automation but in calibrating how much of the factory to build, buy, or leave manual as team scale and trust in the plan grow. - The AI-Native SDLC playbook Louis Claxton · 2026-08-21 source ↗ Reader 🖥️
Once agentic coding collapses the build phase to hours, the traditional SDLC's human-speed controls (committees, meetings, line-by-line review) become the bottleneck and stop matching reality, so organizations should rebuild the lifecycle as a non-linear loop of six stages (plan, design, build, test, deploy, maintain) where every stage commits a version-controlled artifact the next stage reads, human judgment concentrates at artifact-acceptance gates rather than at the point of production, and governance is enforced as code (hooks, branch protection, managed settings) rather than through periodic human review bodies. - agent-skills/docs/comparison.md at main · addyosmani/agent-skills · GitHub Addy Osmani · 2026-07-28 Reader 🖥️
agent-skills, Superpowers, and Matt Pocock's skills all encode good agentic-engineering discipline but optimize for different moments in the work — full product-lifecycle governance with human checkpoints (agent-skills), autonomous reasoning-heavy execution (Superpowers), or a sharp personal daily toolkit (Matt Pocock) — and while the piece insists 'none of them is best in the abstract,' its own structure (author's project profiled first-person, most elaborated column, sole cited empirical case study, broadest 'reach for X' pitch) quietly tilts the honest map toward agent-skills. - mattpocock/skills v1.1: does /wayfinder beat grill-with-docs? Matt Pocock (AI Hero) · 2026-07-08 source ↗ Reader 🖥️
Pocock announces that v1.1 of his Claude Code skills repo now composes a complete agentic coding lifecycle (Grill -> Spec -> Tickets -> Implement -> Code Review), whose headline addition, /wayfinder, decomposes a plan too big for one session into agent-sized chunks mapped as GitHub issues with blocking edges so the work can be parallelized. - AWS Expands DevOps Agent with AI-Powered Release Management to Validate Code Before Production Craig Risi · 2026-07-07 source ↗ Reader 🖥️
AWS's expanded DevOps Agent — adding Release Readiness Review and Autonomous Release Testing — reflects, and is offered as the industry's answer to, a shift in the software-delivery bottleneck from writing code to validating and releasing it safely at AI-accelerated volume. - We don't write code anymore Vincent Quigley · 2026-06-12 source ↗ Reader 🖥️
Software engineering has entered a fourth generation of abstraction in which implementation is cheap and the hardest, most valuable work has moved up a level to framing, specifying, steering, and reviewing — which requires engineers, teams, and engineering management itself to reorganize around judgment and review capacity rather than code production. - Git real: AI agents aren’t just for solo developers anymore Janakiram MSV · 2026-06-09 source ↗ Reader 🖥️
The coding agent is becoming team infrastructure rather than a personal productivity tool — a shift evidenced by three separate vendor launches in one week, each solving a different team-scale problem (coordination, management, governance), that recapitulates the trajectory version control took from private convenience to Git/CI-governed shared practice.
Propositions touching this concept (6)
By publication month, oldest first (extraction month when no publication date is known).
2026-04
- explicitThe software development lifecycle can be decomposed into six phases (Define, Plan, Build, Verify, Review, Ship) that together ensure quality.
2026-05
- explicitThe entire software development lifecycle — both upstream design processes and downstream review/ops — was implicitly designed around the assumption that code production takes roughly a day per few hundred lines, and that assumption is now broken.
2026-06
- explicitRoughly 70% of the code Hanselman personally writes today is AI-augmented, but it is safe only because it flows through the same software development lifecycle (code signing, testing, GitHub Actions, Dependabot, agentic review) as code from any other source.
2026-08
- explicitThe traditional software development lifecycle (including agile practice) exists specifically to compensate for human fragility; what an agentic-era SDLC should look like once code and tests can be wholesale-regenerated on demand is genuinely undetermined.
2026-09
- explicitUniversity coursework (small group projects) does not teach the real software development lifecycle; that gap increasingly has to be closed by industry-embedded internships and cohorts, ideally consuming most of the senior year.
- explicitClaude Code's current comparative advantage is code implementation; the durable industry-wide direction is turning the rest of the software development lifecycle (review, CI/CD, incident response, feedback triage) into agent-run loops as well.
Open gaps (10)
- incompleteNo evidence (adoption numbers, incident-rate change, false-positive rate) is offered that this preview actually improves release safety or speed — the piece is a product announcement, not a study.AWS Expands DevOps Agent with AI-Powered Release Management to Validate Code Before Production — read next: Case studies or retrospectives after general availability.
- incompleteEvery play redefines the human's role (from author to reviewer, from implementer to orchestrator, from on-call responder to incident-queue triager) but the piece never addresses the human cost of that shift — skill atrophy from no longer writing code directly, morale effects of reviewing AI output all day, or how an organization trains new engineers who never practiced the skills the plays assume a senior reviewer already has.The AI-Native SDLC playbook — read next: Look for practitioner accounts (not vendor playbooks) of how teams that have run this kind of pipeline for a year or more describe the experience of the reviewer-not-author role, and whether junior engineers develop judgment without first doing the work themselves.
- uninformedThe piece is presented as consolidating 'real best practices our Applied AI team executes on a daily basis for our customers,' but every quantitative claim (leading/lagging indicators, 'elapsed time falls from weeks to hours') is prescriptive guidance on what to measure, not a reported result; no outcome data from an actual deployment appears anywhere in the piece.The AI-Native SDLC playbook — read next: Look for independent case studies, post-mortems, or DORA-style empirical measurement of organizations that adopted this specific stage structure, as distinct from vendor-authored playbooks.
- incompleteThe article names new products and architectural requirements but presents no case study, benchmark, or production evidence that an organization has actually run this architecture at scale and gotten the promised reliability — it's a capability announcement, not a demonstrated result.Cloudflare Introduces the Agent Development Lifecycle to Replace Traditional SDLC — read next: Look for a follow-up piece or independent case study of a team that adopted Cloudflare's ADLC/Workflows/Agent Access Model stack in production, with concrete before/after delivery metrics.
- uninformedPreview deployments 'for every agent... simultaneously' are presented as simply eliminating staging bottlenecks, without addressing the cost, provisioning latency, or data-freshness drift of spinning up per-agent preview environments at agent-task frequency (potentially much higher than per-PR frequency).Cloudflare Introduces the Agent Development Lifecycle to Replace Traditional SDLC — read next: Cost/latency data on ephemeral preview-environment provisioning at agent-task scale, as opposed to human-PR scale.
- illogicalThe piece frames the novelty as 'teams' newly needing shared infrastructure, echoing version control's move from individual to team practice. But most engineering organizations already ran multiple developers against shared repos, CI, and review policy long before coding agents existed — the genuinely new thing is agents needing to join structures teams already had, not teams needing structure for the first time. Framing it as the team's transition (rather than the agent's transition into an existing team structure) overstates how novel the underlying organizational need is, even though the agent-specific engineering (shared agent memory, multi-agent collision avoidance) is genuinely new.Git real: AI agents aren’t just for solo developers anymore — read next: Re-read the 'per-developer harness to a team one' section against any prior extraction on how CI/PR review policy already governed pre-agent engineering teams, to isolate what's actually new here versus restated.
- incompleteThe build→buy→build-again curve across organizational scale rests on exactly two data points at the extremes — the author's own solo practice at the small end, and OpenAI's self-reported internal Codex pipeline at the largest end — with no examples, metrics, or switching-cost discussion from the broad middle range (roughly 10-100 engineers) where most organizations actually operate.Inside a Software Factory — read next: Look for practitioner reports from mid-size engineering orgs that have adopted or abandoned Factory.ai or Warp's Oz, to test whether the two-endpoint curve generalizes or whether the middle regime behaves differently than either anchor suggests.
- incompleteThe CapEx/OpEx accounting (Figure 9) is a clean two-bucket schematic, but never addresses who inside an organization actually bears the upfront CapEx — often the platform/infra team or a specific engineer, who is rarely rewarded on the same cycle as the feature team that looks fast by vibe coding. The 'for organizations' advice ('treat it as an engineering investment') doesn't engage this incentive-misalignment risk at all.The New SDLC With Vibe Coding: From ad-hoc prompting to Agentic Engineering — read next: Team-topology or incentive-design material on how to attribute/reward harness investment separately from feature-delivery speed.
- uninformedThe headline claim ('OpenAI... 3 engineers. 1 million lines of code. Zero human-written code') is asserted without a source link, named team, project, or any verifiable detail, and the post offers no way to check whether the 'playbook' it summarizes is an official OpenAI publication or a secondhand paraphrase (the author credits a commenter for 'dropping' the article, but never names or links it).Agent-First Engineering: 9 Playbook Tips for a Zero-Human-Code Future — read next: Before treating this as evidence, locate and read the actual source article/playbook it claims to summarize to check whether the tips and the headline figures are accurately represented.
- uninformedAll reported practice comes from one senior, well-resourced team (10+ years' experience each) at a company absorbing roughly $2,000/month per engineer in AI spend; the piece generalizes 'the review bar cannot drop' and 'months of coaching to get good engineers up to standard' as achievable expectations without addressing whether less senior, less resourced, or more cost-constrained teams can sustain the same review intensity, or what happens to engineers who never built hand-written-code intuition in the first place.