# The AI Development Workflows Landscape: From a Five-Step Skeleton to an Enterprise Delivery Closed Loop

The three best-practice ecosystems of Claude Code, Codex CLI, and Gemini CLI show striking convergence on development workflows: mainstream AI development workflows are all converging on the same skeleton:

Research → Plan → Execute → Review → Ship

The point isn’t to mechanically execute five steps, but to upgrade AI development from “single-prompt code writing” into a traceable, verifiable, auditable delivery closed loop.

Three-Layer Loop Composition

Layer	Core question	Key practices
Middle Loop	What should the AI do, look at, and stay within the bounds of?	OpenSpec/Spec Kit, Context Pack, Plan Mode, permissions and hooks
Inner Loop	How does the AI make small, reliable code changes?	TDD, worktrees, subagents, systematic debugging
Outer Loop	How does AI code enter the organization’s delivery system?	PR, CI/CD, SAST, E2E, DORA metrics

See Inner / Middle / Outer Loop and Loop Engineering.

The Five-Step Skeleton in Detail

Stage	Core question	Common artifacts
Research	What is the system? What are the requirements and constraints?	Codebase investigation, Context Pack, risk scan
Plan	How will it be done? How will completion be proven?	Plan, acceptance criteria, test strategy
Execute	How to implement in small steps while controlling drift?	Small PRs, TDD, worktrees, phase handoff
Review	Is the result correct, safe, and maintainable?	Code review, QA report, independent evaluator
Ship	How does it enter the delivery system and feed learning back?	PR, CI/CD, changelog, retro, metrics

The minimum unit of a workflow is upgrading from a prompt template to a process asset — one with an entry point, state, artifacts, checkpoints, and exit conditions. Superpowers packages TDD/review skills; OpenSpec/Spec Kit version spec artifacts; gstack makes expert gears explicit; GSD uses fresh-context subagents to resist context rot.

An Enterprise Reference Model: 0+6 Stages

0. Policy & Routing     → tool tier, data boundaries, human gate
1. Research & Spec      → intent, constraints, acceptance criteria
2. Plan & Contract      → task decomposition, definition of done, risk, rollback
3. Execute in Batches   → TDD, worktree, small PRs
4. Independent Review   → CR, runtime tests, QA, security
5. Ship                 → PR, CI/CD, monitoring, rollback
6. Archive & Improve    → sync specs, update skills, metrics

Ontology Classification: First Ask “What Is It?”

Classifying directly by the five stages confuses projects like OpenSpec, GSD, and gstack that span multiple stages. Instead, classify by primary ontology:

Ontology category	Criteria	Representative projects
Workflow Method Framework	Defines a complete method, stages, artifacts, gates	Spec Kit, OpenSpec, BMAD, GSD, Superpowers, gstack, HumanLayer
Workflow Capability / Skill Collection	Reusable building blocks, doesn’t mandate a single E2E method	Matt Pocock Skills, agent-skills
Runtime Harness Pack	Enhances configuration and orchestration for a specific runtime	ECC, oh-my-claudecode, oh-my-codex

Boundary: Claude Code, Codex, and Cursor are Agent Runtimes, not workflow methods; MCP, GitHub Actions, and Playwright are infrastructure that supports but doesn’t prescribe a complete method.

Overview of Mainstream Workflow Projects

Project	Workflow summary	Ontology
Superpowers	brainstorming → plans → TDD → review → verification	Engineering-discipline framework
Spec Kit	constitution → specify → plan → tasks → implement	SDD standard
OpenSpec	propose → apply → verify → archive	Brownfield change-oriented
GSD	discuss → plan → execute → verify → ship	Execution orchestration + context engineering
gstack	plan reviews → qa → ship → retro	Expert-role oriented
BMAD	Multi-role agile with PM/Architect/Dev/UX/QA	Role-division oriented

See SDD Tools Comparison for a full SDD comparison.

Five Questions for Selecting a Tool

Question	If the answer is “yes”	Prioritize
Are requirements/acceptance boundaries unclear?	Structure intent first	Spec Kit / OpenSpec / BMAD
Does the agent often drift off course or skip tests?	Strengthen execution discipline	Superpowers / GSD
Missing product/design/QA perspective challenge?	Make expert review explicit	gstack / BMAD
Runtime already chosen?	Adapt to native commands/hooks	ECC / AGENTS.md / CLAUDE.md
Must enter the enterprise release chain?	Wire into CI/CD and metrics	Actions / Playwright / DORA

Common Scenario Combinations

Scenario	Recommended combination
Low-risk small fix	Runtime plan + targeted verification
Brownfield feature	OpenSpec/Spec Kit + Superpowers TDD + CI gate
UI / full-stack	Spec + design review + Playwright evidence
Long-horizon migration	GSD phase graph + worktree + batched PRs
High-risk change	Spec + human gate + security review + rollback plan

For layered tool-chain practice, see OpenSpec + Superpowers + gstack and GStack + GSD + Superpowers.

The Sub-Loops Are the Hard Part

AI development risk usually doesn’t live in the happy path, but in the sub-loops:

• Test fails → systematic debugging or a guess-fix?
• Review finds an issue → back to plan, or stack a patch?
• CI fails → can it be localized, fixed, with evidence preserved?

Process design must define: which steps can repeat, what the stop condition is, and when to escalate to a human.

Runtime Primitives Set the Ceiling

Runtime	Orchestration capability	Implication
Claude Code	Command → Agent → Skill, fairly complete	Complex playbooks, expert review
Codex CLI	Agent → Skill + slash controls	Implementation worker; supplement orchestration with AGENTS.md/CI
Gemini CLI	Command → Agent → Skill; large context	Large-context research, TOML commands

Methodology shouldn’t be bound to a single tool, but at implementation time you must know what each runtime can natively carry.

Key Principles

1. Spec as Source of Truth — requirements and behavior changes must be versionable, not confined to chat history
2. Context Pack — referenceable and incrementally loadable, not dumped in wholesale
3. Separation of Planner / Generator / Evaluator — the Generator’s self-assessment is overly optimistic; an independent Evaluator is more reliable
4. Don’t bypass the Outer Loop — AI-generated code still goes through PR, CI/CD, metrics

References

• Superpowers: https://github.com/obra/superpowers
• GitHub Spec Kit: https://github.com/github/spec-kit
• OpenSpec: https://github.com/Fission-AI/OpenSpec