feature-loop

Orchestrates a change request from intake through implementation, shipping, monitoring, and retro follow-up.

Updated May 17, 2022
One-click install
npx skills add https://github.com/kanade0404/dotfiles --skill feature-loop-kanade0404
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: feature-loop
Source: https://github.com/kanade0404/dotfiles/tree/main/.opencode/skills/feature-loop
Command: npx skills add https://github.com/kanade0404/dotfiles --skill feature-loop-kanade0404

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill coordinates a full feature delivery loop when you want one change request handled from intake all the way to implementation, shipping, PR monitoring, and retrospective follow-up without managing each handoff yourself.

Core Features & Use Cases

  • Intake Triage: Decides whether the request is light or heavy based on clarity, scope, and design uncertainty, then routes to the right next step.
  • Implementation Routing: Delegates behavior changes to TDD and structural changes to tidy-first so the work starts with the right method.
  • Shipping and Monitoring: Hands off to shipping for quality gates and PR readiness, then to PR monitoring until merge or close is resolved.
  • Use Case: A user says they want a new feature handled end to end, and this Skill keeps the process moving from acceptance criteria through delivery and final outcome tracking.

Quick Start

Tell the feature-loop skill that you want a change request handled from start to finish and it will take care of the intake, implementation, shipping, and monitoring flow.

Frequently Asked Questions about feature-loop

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I manage feature delivery from intake to merge-ready without manual handoffs?

Feature delivery orchestration coordinates the entire workflow from intake through implementation, shipping, PR monitoring, and retro follow-up automatically. It routes requests based on clarity and scope, delegates to TDD or tidy-first methods, and tracks outcomes until merge or close is resolved.

What is the best way to orchestrate TDD behavior changes and structural refactoring in one workflow?

Implementation routing delegates behavior changes to TDD and structural changes to tidy-first, ensuring work starts with the right method. This deterministic handoff approach routes tasks based on the nature of the change, applying test-driven development for behaviors and structural cleanup for refactoring.

How does PR monitoring work for a feature delivery pipeline that stops at merge-ready?

PR monitoring tracks pull requests until merge or close is resolved without performing merges itself. The pipeline hands off to shipping for quality gates and PR readiness first, then monitors the PR status as a safe delegation step with explicit merge-ready stopping conditions.

Can I use automated retrospective follow-up after a feature is shipped and merged?

Automated retrospective follow-up is included as the final stage of the feature delivery loop. After shipping and PR monitoring resolve to merge or close, the workflow triggers post-merge follow-up actions, completing the end-to-end cycle from initial request intake.

Does feature delivery orchestration work for single-change requests with unclear requirements?

Single-change requests with unclear requirements are handled through intake triage, which evaluates clarity, scope, and design uncertainty. The intake decisioning process determines whether the request is light or heavy, then explicitly routes to the appropriate next step for requirement clarification before implementation begins.

When should I not use an end-to-end feature delivery loop for pull request preparation?

End-to-end feature delivery loops are designed for single-change requests, not multi-change batches or complex cross-system migrations. The workflow requires deterministic handoffs and explicit stopping conditions, meaning it should not be used when you need to perform merges yourself or when changes lack clear acceptance criteria.