Orchestrate End-to-End Feature Development
Skill that orchestrates specialist sub-agents through discovery, implementation, testing, and deployment for end-to-end feature delivery.
Why it matters
Automate the complete lifecycle of backend feature development, from initial requirements and architecture design through implementation, testing, and production deployment.
Outcomes
What it gets done
Define feature scope, success metrics, and technical architecture.
Implement backend services, frontend components, and data pipelines.
Generate automated test suites and perform security validation.
Prepare and execute deployment strategies with monitoring and rollback plans.
Install
Add it to your toolbox
Run in your project directory:
curl -fsSL https://spark.entire.vc/get/ag-backend-development-feature-development | bash Overview
Backend Development Feature Development
A 4-phase, 12-step orchestration skill that delegates feature discovery, implementation, testing, and deployment to named specialist sub-agents, passing each phase's output as context into the next. Use for coordinating a multi-team, multi-service feature with a real deployment and monitoring plan, not for a small isolated backend change.
What it does
A 12-step, 4-phase orchestration skill that coordinates specialized sub-agents through the full feature development lifecycle, from requirements to production deployment. Phase 1 (Discovery and Requirements) calls a business-analyst to define user stories and success metrics, an architect-review agent to design technical architecture and API contracts, and a security-auditor to assess risk and compliance. Phase 2 (Implementation) calls a backend-architect to build APIs with resilience patterns and feature flags, a frontend-developer to build UI with feature-flag-driven A/B testing, and a data-engineer to build ETL pipelines and analytics events. Phase 3 (Testing and QA) calls a test-automator for unit, integration, E2E, and performance tests targeting a minimum 80% coverage, the security-auditor again for OWASP checks and penetration testing, and a performance-engineer for profiling and query/caching optimization. Phase 4 (Deployment and Monitoring) calls a deployment-engineer to build CI/CD with feature flags, blue-green rollout, and a rollback runbook, an observability-engineer to set up tracing, dashboards, and SLOs/SLIs, and a docs-architect to generate API docs, runbooks, and architecture documentation. Each phase's output feeds as explicit context into the next agent's prompt. The rollback strategy is staged by speed: disable the feature flag in under a minute, switch blue-green traffic in under five minutes, or fall back to a full CI/CD deployment rollback in under fifteen minutes, coordinating a database migration rollback with the data team if needed before an incident post-mortem.
When to use - and when NOT to
Use for coordinating end-to-end feature delivery that spans backend, frontend, and data, needs multi-team alignment on scope and risk, and will require a real deployment and monitoring plan. Do not use for a small, isolated backend change or bug fix, when only a single specialist task is needed rather than a full workflow, or when there is no deployment or cross-team coordination involved.
Inputs and outputs
Required parameters: --feature (name and description), --methodology (traditional, tdd, bdd, or ddd), --complexity (simple 1-2 days, medium 3-5 days, complex 1-2 weeks, or epic 2+ weeks). Optional parameters configure --deployment-strategy (direct, canary, feature-flag, blue-green, or a-b-test), --test-coverage-min (default 80%), --performance-budget, --rollout-percentage (default 5%), and named tool integrations for --feature-flag-service, --analytics-platform, and --monitoring-stack. Output across the 12 steps is a requirements document, architecture document, security assessment, working backend, frontend, and data-pipeline code, a full test suite, a CI/CD deployment pipeline with rollback procedures, monitoring dashboards and SLOs, and complete documentation.
Integrations
Delegates to named specialist sub-agents via the Task tool: business-analyst, architect-review, security-auditor, backend-architect, frontend-developer, data-engineer, test-automator, performance-engineer, deployment-engineer, observability-engineer, and docs-architect. Supports pluggable feature-flag providers (LaunchDarkly, Split, Unleash, or custom), analytics platforms (Segment, Amplitude, Mixpanel, or custom), and monitoring stacks (Datadog, New Relic, Grafana, or custom).
Who it's for
Engineering leads or platform teams orchestrating a non-trivial feature across multiple specialties who want a repeatable phase structure - discovery, implementation, testing, deployment - with explicit rollback and observability built in, rather than ad-hoc coordination.
Source README
[Extended thinking: This workflow orchestrates specialized agents through comprehensive feature development phases - from discovery and planning through implementation, testing, and deployment. Each phase builds on previous outputs, ensuring coherent feature delivery. The workflow supports multiple development methodologies (traditional, TDD/BDD, DDD), feature complexity levels, and modern deployment strategies including feature flags, gradual rollouts, and observability-first development. Agents receive detailed context from previous phases to maintain consistency and quality throughout the development lifecycle.]
FAQ
Common questions
Discussion
Questions & comments · 0
Sign In Sign in to leave a comment.