software-delivery-orchestrator

Software Delivery Orchestrator

Software Delivery Orchestrator is an end-to-end software delivery workflow for coding agents, packaged as a reusable skill.

It is built for feature work in existing repositories. Instead of jumping straight into implementation, it pushes the agent through requirement challenge, spec creation, technical planning, implementation, review, and documentation sync.

This repository is organized as a multi-platform skill distribution repo:

• skills/ holds the real skill source
• .claude-plugin/, .cursor-plugin/, .codex/ hold platform-specific entry files
• package.json + scripts/ drive regeneration and CI checks

What This Skill Does

software-delivery-orchestrator is for tasks where an agent should act like a disciplined delivery lead, not just a code generator.

Use it when you want the agent to:

• turn a rough feature request into a structured delivery workflow
• challenge unclear or risky requirements before implementation starts
• separate product goals from proposed implementation details
• produce a canonical spec and technical plan
• implement in small slices with validation
• run review loops before calling the work complete
• keep documentation and durable knowledge in sync with the final code

This skill is most useful for:

• feature delivery in an existing repository
• changes that need planning before coding
• work that should include review and documentation updates
• tasks where you want stronger process discipline and less implementation drift

How It Works

From the first user request, the skill tries to move the agent through a controlled delivery loop:

1. Clarify the product goal and separate it from the user's proposed implementation.
2. Challenge bad or incomplete requirements before code starts.
3. Produce a canonical spec and technical plan.
4. Implement in small, auditable slices with validation.
5. Run review loops, documentation sync, and knowledge capture before declaring completion.

The goal is not “write code faster.” The goal is “ship changes with less ambiguity, less drift, and better review discipline.”

Subagent Lifecycles

This skill does not treat subagents as globally resident helpers. It reuses them only while the same stage, owned artifact, and responsibility remain active.

• Stage-bound: initialization doc agents and most bootstrap research agents should close after their stage artifacts are finalized.
• Feature-spec-bound: the requirement proposer and challenger may be reused across requirement gate and requirement analysis, but only for the same current feature spec.
• Slice-bound: frontend or backend implementers, and any follow-up fixer, stay alive only while the same owned code slice remains active.
• Round-bound: the reviewer is fresh for each meaningful review round and should not be reused after code, test, or validation evidence changes.
• Artifact-bound: documentation-sync and knowledge may span multiple review rounds, but only until the current feature's artifacts are finalized against the latest accepted diff.

In other words, the skill prefers explicit ownership and clean handoffs, not long-lived background subagents that linger into later unrelated stages or the next feature.

Typical requests that should trigger this skill:

• "Turn this feature request into a delivery workflow"
• "Challenge this implementation idea before we code"
• "Plan and execute this feature with review and documentation sync"
• "Help me scope, implement, review, and document this change"

Installation

Installation differs by platform. Claude Code uses a plugin marketplace. Cursor uses native skill discovery. Codex uses native skill discovery plus a local clone.

GitHub repository:

https://github.com/xhyqaq/software-delivery-orchestrator

The source of truth is:

skills/software-delivery-orchestrator/

Generated compatibility files are:

• AGENTS.md
• .claude-plugin/plugin.json
• .claude-plugin/marketplace.json
• .cursor-plugin/plugin.json
• .codex/INSTALL.md

Claude Code

Add the repository as a marketplace:

/plugin marketplace add xhyqaq/software-delivery-orchestrator

Then install the software-delivery-orchestrator plugin from that marketplace.

Cursor

Cursor's AI Agent discovers skills from ~/.codex/skills/ and ~/.agents/skills/. Choose one of the following methods:

Method A (recommended): use the built-in skill installer

In a Cursor AI Agent session, ask it to install the skill from GitHub:

Install the skill from https://github.com/xhyqaq/software-delivery-orchestrator using the skill installer.

The agent will use install-skill-from-github.py to copy the skill into ~/.codex/skills/software-delivery-orchestrator/ automatically.

Method B: manual install