changes

Manage change requests through decomposition, parallel planning, and serial implementation.

Updated Sep 17, 2019
One-click install
npx skills add https://github.com/wwlorey/dotfiles --skill changes-wwlorey
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: changes
Source: https://github.com/wwlorey/dotfiles/tree/main/.agents/skills/changes
Command: npx skills add https://github.com/wwlorey/dotfiles --skill changes-wwlorey

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill simplifies the process of managing and implementing change requests, from initial framing to planning, implementation, and verification.

Core Features & Use Cases

  • Change Request Management: Handle user-defined change requests efficiently.
  • Decomposition: Break down large change requests into smaller, manageable items.
  • Parallel Planning: Concurrently gather information and draft plans for change items.
  • Serial Implementation: Implement changes in a controlled, sequential manner.
  • Commit Tracking: Monitor the progress of changes through multiple small commits.
  • Use Case: When a user requests a new feature or bug fix, this Skill guides the development process, ensuring each step is completed with attention to detail and quality.

Quick Start

Run the changes skill to start handling a new change request, and follow the guided steps for decomposition, planning, implementation, and verification.

Frequently Asked Questions about changes

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

FAQPage Schema
What is parallel planning and serial implementation in change request management?

Parallel planning and serial implementation is a development workflow that concurrently gathers information and drafts plans for change items, then implements those changes sequentially. This approach enforces atomicity at the sub-piece level to maintain controlled, high-quality modifications.

How do I manage the lifecycle of a change request from framing to verification?

You manage a change request lifecycle by decomposing user-framed requests into smaller items, concurrently planning those items, and sequentially implementing them. Progress is tracked through multiple small commits to ensure strict adherence to the defined workflow and atomic verification.

How do I break down large software change requests into manageable items?

You break down large change requests by running a guided decomposition process that splits user requests into smaller, manageable items. This enables concurrent information gathering and drafting of plans before any sequential implementation begins.

Can I coordinate multiple workers during parallel change planning?

Yes, this change management workflow requires coordination of multiple workers to handle parallel planning. Workers concurrently gather information and draft plans for decomposed change items before the serial implementation phase begins.

What is the best way to track progress during a serial implementation workflow?

The best way to track progress during serial implementation is by monitoring multiple small commits. This ensures changes are implemented sequentially in a controlled manner and verifies atomicity at the sub-piece level throughout the development workflow.

When should I not use a serial implementation approach for change requests?

You should avoid serial implementation when strict workflow adherence and sub-piece atomicity are not required. This approach coordinates multiple workers sequentially, making it less suitable for rapid, unstructured modifications that bypass controlled commit tracking.