sre-task-refinement

Refine bd task plans into actionable subtasks with SRE-level review.

80|17|Updated Oct 27, 2025
One-click install
npx skills add https://github.com/withzombies/hyperpowers --skill sre-task-refinement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sre-task-refinement
Source: https://github.com/withzombies/hyperpowers/tree/main/skills/sre-task-refinement
Command: npx skills add https://github.com/withzombies/hyperpowers --skill sre-task-refinement

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill refines bd tasks into highly actionable, junior-engineer-ready plans, preventing production issues and ensuring implementability. It applies a rigorous SRE-level review to catch hidden failure modes, edge cases, and vague instructions before implementation.

Core Features & Use Cases

  • SRE-Level Review: Critically examines task granularity, implementability, success criteria, dependencies, safety standards, and potential edge cases.
  • Issue Enhancement: Updates bd issues with missing details, clarifications, warnings, and strengthened anti-patterns.
  • Task Breakdown: Automatically breaks down overly large tasks (>16 hours) into smaller, manageable subtasks (4-8 hours) with complete, self-contained designs.
  • Use Case: After a feature plan is drafted in bd, use this Skill to review all tasks from the perspective of a Google Fellow SRE, ensuring no critical gaps or potential production issues are overlooked.

Quick Start

Use the sre-task-refinement skill to review the plan for bd-1.

Frequently Asked Questions about sre-task-refinement

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

FAQPage Schema
How do I review task plans to catch production issues before implementation?

Task refinement applies SRE-level review to examine granularity, implementability, success criteria, dependencies, safety standards, and edge cases. It identifies hidden failure modes and vague instructions that could cause production problems, ensuring junior engineers can execute tasks without ambiguity.

What makes a task plan actionable for junior engineers?

Actionable plans require clear granularity (4-8 hour subtasks), 3+ measurable success criteria, explicit dependency structure, complete safety standards, edge-case coverage, and meaningful tests. Task refinement enforces these eight categories systematically to eliminate implementation blockers.

When should I break down large tasks into smaller subtasks?

Tasks exceeding 16 hours should be broken into 4-8 hour subtasks with self-contained designs. This granularity prevents implementation paralysis, reduces risk of hidden dependencies, and enables junior engineers to complete work without extended context switching.

How do I identify edge cases and red flags in task planning?

SRE-level review systematically examines dependencies, safety assumptions, and boundary conditions to surface hidden failure modes. Red flag detection catches antipatterns and incomplete specifications that testing alone might miss, preventing production incidents.

What's the difference between vague and testable success criteria?

Measurable success criteria are quantifiable, observable outcomes tied to task completion. Task refinement requires 3+ per task to eliminate subjective interpretation and ensure tests validate actual functionality rather than ambiguous intent.