Backend Development Feature Development
Coordinate a full backend feature from requirements through implementation, testing, and production rollout when multiple services or teams are involved.
Overview
Backend Development Feature Development is an agent skill most often used in Build (also Validate scope work and Ship launch) that orchestrates end-to-end backend feature delivery from requirements through deployment.
Install
npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill backend-development-feature-developmentWhat is this skill?
- Multi-phase orchestration from discovery and planning through implementation, testing, and deployment
- Supports traditional, TDD/BDD, and DDD-oriented delivery paths
- Covers feature flags, gradual rollouts, and observability-first rollout patterns
- Explicit handoffs between specialized agent phases with context carried forward
- Scoped for cross-team scope, risks, and success metrics—not single-file patches
Adoption & trust: 540 installs on skills.sh; 40.1k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You have a multi-service backend feature but no structured agent workflow that carries context from requirements through rollout and monitoring.
Who is it for?
Indie builders shipping a non-trivial API or backend feature that spans services, needs rollout strategy, and benefits from explicit validate→build→ship sequencing.
Skip if: Tiny isolated backend bug fixes, single-file changes, or tasks with no deployment or cross-service coordination needs.
When should I use this skill?
Coordinating end-to-end feature delivery across backend, frontend, and data; managing requirements, architecture, implementation, testing, and rollout; planning multi-service changes with deployment and monitoring needs.
What do I get? / Deliverables
You get a phased delivery plan with implementation, testing, and deployment coordination aligned on scope, risks, and success metrics—ready to execute or split across follow-up specialist skills.
- Phased feature delivery plan
- Implementation and test coordination notes
- Rollout and observability checklist
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Build because the skill centers on backend feature delivery and cross-service implementation, even though it extends into validate-style planning and ship-style deployment. Backend is the primary surface: APIs, services, data contracts, and deployment hooks—not a one-off frontend tweak or isolated bug fix.
Where it fits
Define service boundaries, risks, and success metrics before agents start coding a multi-API feature.
Drive implementation and integration across backend services with context passed between agent phases.
Align third-party and internal service contracts while the feature is being built.
Plan feature-flag rollout, gradual release, and observability checks before full traffic.
How it compares
Use instead of ad-hoc 'build the API' chat when the work is a coordinated feature program, not one specialist subtask.
Common Questions / FAQ
Who is backend-development-feature-development for?
Solo builders and small teams shipping backend features that cross services or need planned rollout, testing, and observability—not one-line fixes.
When should I use backend-development-feature-development?
During Validate when scoping a multi-service change, during Build when coordinating backend implementation, and during Ship when planning flags, gradual rollout, and monitoring for the same feature.
Is backend-development-feature-development safe to install?
Review the Security Audits panel on this Prism page for community sourcing and risk signals before running orchestration workflows in your repo or production environments.
SKILL.md
READMESKILL.md - Backend Development Feature Development
Orchestrate end-to-end feature development from requirements to production deployment: [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.] ## Use this skill when - Coordinating end-to-end feature delivery across backend, frontend, and data - Managing requirements, architecture, implementation, testing, and rollout - Planning multi-service changes with deployment and monitoring needs - Aligning teams on scope, risks, and success metrics ## Do not use this skill when - The task is a small, isolated backend change or bug fix - You only need a single specialist task, not a full workflow - There is no deployment or cross-team coordination involved ## Instructions 1. Confirm feature scope, success metrics, and constraints. 2. Select a methodology and define phase outputs. 3. Orchestrate implementation, testing, and security validation. 4. Prepare rollout, monitoring, and documentation plans. ## Safety - Avoid production changes without approvals and rollback plans. - Validate data migrations and feature flags in staging first. ## Configuration Options ### Development Methodology - **traditional**: Sequential development with testing after implementation - **tdd**: Test-Driven Development with red-green-refactor cycles - **bdd**: Behavior-Driven Development with scenario-based testing - **ddd**: Domain-Driven Design with bounded contexts and aggregates ### Feature Complexity - **simple**: Single service, minimal integration (1-2 days) - **medium**: Multiple services, moderate integration (3-5 days) - **complex**: Cross-domain, extensive integration (1-2 weeks) - **epic**: Major architectural changes, multiple teams (2+ weeks) ### Deployment Strategy - **direct**: Immediate rollout to all users - **canary**: Gradual rollout starting with 5% of traffic - **feature-flag**: Controlled activation via feature toggles - **blue-green**: Zero-downtime deployment with instant rollback - **a-b-test**: Split traffic for experimentation and metrics ## Phase 1: Discovery & Requirements Planning 1. **Business Analysis & Requirements** - Use Task tool with subagent_type="business-analytics::business-analyst" - Prompt: "Analyze feature requirements for: $ARGUMENTS. Define user stories, acceptance criteria, success metrics, and business value. Identify stakeholders, dependencies, and risks. Create feature specification document with clear scope boundaries." - Expected output: Requirements document with user stories, success metrics, risk assessment - Context: Initial feature request and business context 2. **Technical Architecture Design** - Use Task tool with subagent_type="comprehensive-review::architect-review" - Prompt: "Design technical architecture for feature: $ARGUMENTS. Using requirements: [include business analysis from step 1]. Define service boundaries, API contracts, data models, integration points, and technology stack. Consider scalability, performance, and security requirements." - Expected output: Technical design document with architecture diagrams, API specifications, data models - Context: Business requirements, existing system architecture 3. *