skills.rest
mo7amedElfadil
mo7amedElfadilCOMMUNITY
Explore all skills by this author →
GitHub

maintaining-planning

Orchestrate multi-step tasks into atomic RED/GREEN/REFACTOR actions with verification commands.

Updated Aug 23, 2026
Search Tags:#workflow#planning#task management#refactoring#verification#decomposition
One-click install
npx skills add https://github.com/mo7amedElfadil/bidOps --skill maintaining-planning
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: maintaining-planning
Source: https://github.com/mo7amedElfadil/bidOps/tree/main/.agent/skills/maintaining-planning
Command: npx skills add https://github.com/mo7amedElfadil/bidOps --skill maintaining-planning

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill streamlines the management of intricate, multi-step tasks by breaking them down into manageable, verifiable actions, ensuring clarity and progress.

Core Features & Use Cases

  • Task Decomposition: Breaks down large tasks into atomic, actionable steps.
  • Verification: Includes specific commands or tests to confirm each step's success.
  • Use Case: When refactoring a core application module, this Skill can plan and guide the execution of database schema changes, API updates, and frontend adjustments sequentially.

Quick Start

Use the maintaining-planning skill to create a plan for refactoring the user authentication module.

Frequently Asked Questions about maintaining-planning

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

FAQPage Schema
How do I orchestrate complex multi-file refactoring tasks?▼

You can orchestrate multi-file refactoring by breaking the work into atomic, verifiable actions defined in a structured plan file. This approach manages dependent sequences like database schema changes and API updates sequentially.

What is the best way to plan architectural changes involving dependent steps?▼

The best way to plan architectural changes is to decompose the work into atomic task definitions within a dedicated plan file. This method structures dependent steps using explicit RED/GREEN/REFACTOR phases and verification commands.

How do I break down a large software engineering workflow into atomic tasks?▼

You break down a software engineering workflow by decomposing it into atomic, actionable steps. Each step requires specific verification commands or tests to confirm its success before progressing.

Do I need a specific directory structure for task management planning files?▼

Yes, this task management approach requires a plan file specifically located in the `docs/plans/` directory. This file must contain atomic task definitions, including RED/GREEN/REFACTOR steps and verification commands.

When should I use atomic task decomposition for software modifications?▼

You should use atomic task decomposition when managing intricate, multi-step software modifications like core module refactoring. It ensures clarity and progress when sequences involve dependent steps requiring explicit verification commands.

Related Skills

Explore More Software Engineering Skills→
Fr-e-dFr-e-d
157

architecture-extract

Analyze project directory structures to generate architectural summaries.

Community
Basic
jrmatherlyjrmatherly
1

shipit-kit:implement

Validate YAML feature specs and execute TDD implementation tasks.

Community
Advanced
zhentingWu-wztzhentingWu-wzt
6

superpowers:verification-before-completion

Enforces empirical command-output verification before declaring a software task complete.

Community
Advanced
synaptiaisynaptiai
6

tdd-patterns

Track RED-GREEN-REFACTOR tasks for TDD cycles in CI workflows.

Official
Intermediate