Skip to content
Back to search

workflow-orchestration

A Claude Code skill for disciplined task execution with planning, verification, and self-improvement loops

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/vxcozy--workflow-orchestration/badge.svg)](/listings/vxcozy--workflow-orchestration)

HTML

<a href="/listings/vxcozy--workflow-orchestration"><img src="/api/listings/vxcozy--workflow-orchestration/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Via skills CLI (Recommended)

npx skills add vxcozy/workflow-orchestration

Manual Installation

**Personal (all projects):**

git clone https://github.com/vxcozy/workflow-orchestration ~/.claude/skills/workflow-orchestration

**Project-specific:**

git clone https://github.com/vxcozy/workflow-orchestration .claude/skills/workflow-orchestration

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 116 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: workflow-orchestration
  3. description: |
  4. Disciplined task execution with planning, verification, and self-improvement loops.
  5. Use when starting non-trivial tasks (3+ steps), fixing bugs, building features,
  6. refactoring code, or when rigorous execution with quality gates is needed.
  7. Includes subagent delegation, lessons tracking, and staff-engineer-level verification.
  8. license: MIT
  9. metadata:
  10. author: vxcozy
  11. version: "1.0.0"
  12. ---
  13. # Workflow Orchestration
  14. Apply these practices for disciplined, high-quality task execution.
  15. ## Quick Reference
  16. | Practice | When to Apply |
  17. |----------|---------------|
  18. | Plan Mode | Any task with 3+ steps or architectural decisions |
  19. | Subagents | Research, exploration, parallel analysis |
  20. | Lessons | After ANY user correction |
  21. | Verification | Before marking any task complete |
  22. | Elegance Check | Non-trivial changes only |
  23. ## 1. Plan Mode Default
  24. - Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
  25. - If something goes sideways, STOP and re-plan immediately
  26. - Use plan mode for verification steps, not just building
  27. - Write detailed specs upfront to reduce ambiguity
  28. ## 2. Subagent Strategy
  29. Keep the main context window clean:
  30. - Offload research, exploration, and parallel analysis to subagents
  31. - For complex problems, throw more compute at it via subagents
  32. - One task per subagent for focused execution
  33. **Template:**
  34. ```
  35. Agent({
  36. description: "Search auth patterns",
  37. prompt: "Find all authentication middleware in src/ and list file paths with a one-line summary of each."
  38. })
  39. ```
  40. ## 3. Self-Improvement Loop
  41. After ANY correction from the user:
  42. 1. Update `tasks/lessons.md` with the pattern
  43. 2. Write rules that prevent the same mistake
  44. 3. Review lessons at session start
  45. **Inline example** (full template in [references/lessons-format.md](references/lessons-format.md)):
  46. ```markdown
  47. ## 2024-01-10 - Testing
  48. **Mistake**: Mocks hid real API behavior; production broke
  49. **Pattern**: Over-mocking created false confidence
  50. **Rule**: Include at least one integration test hitting real services
  51. **Applied**: All API endpoints, external service integrations
  52. ```
  53. ## 4. Verification Before Done
  54. - Never mark a task complete without proving it works
  55. - Diff behavior between main and your changes when relevant
  56. - Ask yourself: "Would a staff engineer approve this?"
  57. - Run tests, check logs, demonstrate corrections
  58. - If verification fails → return to the plan step and revise before retrying
  59. ## 5. Demand Elegance (Balanced)
  60. - For non-trivial changes: pause and ask "is there a more elegant way?"
  61. - If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
  62. - Skip this for simple, obvious fixes—don't over-engineer
  63. ## 6. Autonomous Bug Fixing
  64. - When given a bug report: Just fix it. Don't ask for hand-holding
  65. - Point at logs, errors, failing tests—then resolve them
  66. - Zero context switching required from the user
  67. ## Task Management Protocol
  68. 1. **Plan First**: Write plan to `tasks/todo.md` with checkable items
  69. 2. **Verify Plan**: Check in before starting implementation
  70. 3. **Track Progress**: Mark items complete as you go
  71. 4. **Explain Changes**: High-level summary at each step
  72. 5. **Verify Results**: Run tests and confirm behavior before marking done
  73. 6. **Handle Failures**: If verification fails → re-plan (step 1), don't push through
  74. 7. **Document Results**: Add review to `tasks/todo.md`
  75. 8. **Capture Lessons**: Update `tasks/lessons.md` after corrections
  76. **Inline example** (full templates in [references/task-templates.md](references/task-templates.md)):
  77. ```markdown
  78. # Task: Fix memory leak in WebSocket handler
  79. ## Plan
  80. - [ ] Reproduce the issue locally
  81. - [ ] Identify leak source with profiler
  82. - [ ] Implement fix
  83. - [ ] Verification: Memory stable over 1000 connections
  84. ```
  85. ## Core Principles
  86. - **Simplicity First**: Make every change as simple as possible
  87. - **No Laziness**: Find root causes. No temporary fixes. Senior developer standards
  88. - **Minimal Impact**: Only touch what's necessary. Avoid introducing bugs
README.md · README · 112 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Workflow Orchestration
  2. A skill for disciplined AI agent task execution with planning, verification, and self-improvement loops.
  3. ## Overview
  4. Workflow orchestration provides a systematic approach to complex task execution:
  5. | Practice | Purpose |
  6. |----------|---------|
  7. | **Plan Mode** | Think before acting on non-trivial tasks |
  8. | **Subagent Delegation** | Keep main context clean |
  9. | **Self-Improvement** | Learn from corrections |
  10. | **Verification** | Prove work is complete; re-plan if it fails |
  11. | **Balanced Elegance** | Quality without over-engineering |
  12. | **Autonomous Fixing** | Reduce user burden |
  13. ## Installation
  14. ### Via skills CLI (Recommended)
  15. ```bash
  16. npx skills add vxcozy/workflow-orchestration
  17. ```
  18. ### Manual Installation
  19. **Personal (all projects):**
  20. ```bash
  21. git clone https://github.com/vxcozy/workflow-orchestration ~/.claude/skills/workflow-orchestration
  22. ```
  23. **Project-specific:**
  24. ```bash
  25. git clone https://github.com/vxcozy/workflow-orchestration .claude/skills/workflow-orchestration
  26. ```
  27. ## Usage
  28. ### Direct Invocation
  29. ```
  30. /workflow-orchestration
  31. ```
  32. ### Automatic
  33. The skill activates automatically for:
  34. - Non-trivial tasks (3+ steps)
  35. - Bug fixes and feature work
  36. - Refactoring and architectural changes
  37. ## Documentation
  38. This skill uses [Diataxis](https://diataxis.fr)-style documentation:
  39. | Type | Purpose | Link |
  40. |------|---------|------|
  41. | **Tutorial** | Learn by doing | [docs/tutorial.md](docs/tutorial.md) |
  42. | **How-To** | Solve specific problems | [docs/howto.md](docs/howto.md) |
  43. | **Reference** | Technical details | [references/REFERENCE.md](references/REFERENCE.md) |
  44. | **Explanation** | Understand concepts | [docs/explanation.md](docs/explanation.md) |
  45. ### Additional References
  46. - [Task Templates](references/task-templates.md) - Ready-to-use todo.md formats
  47. - [Lessons Format](references/lessons-format.md) - How to capture learnings
  48. ## File Structure
  49. ```
  50. workflow-orchestration/
  51. ├── SKILL.md # Main skill (loaded by agents)
  52. ├── docs/
  53. │ ├── tutorial.md # Learning-oriented guide
  54. │ ├── howto.md # Task-oriented guides
  55. │ └── explanation.md # Understanding-oriented
  56. ├── references/
  57. │ ├── REFERENCE.md # Complete reference
  58. │ ├── task-templates.md # Todo file templates
  59. │ └── lessons-format.md # Lessons file format
  60. ├── README.md
  61. └── LICENSE
  62. ```
  63. ## Quick Start
  64. 1. Install the skill
  65. 2. Start a non-trivial task
  66. 3. Create `tasks/todo.md` with your plan
  67. 4. Execute with progress tracking
  68. 5. Verify before marking complete (if verification fails, return to planning)
  69. 6. Capture lessons after corrections
  70. ## Core Principles
  71. - **Simplicity First** - Minimal changes, minimal code
  72. - **No Laziness** - Find root causes, no temporary fixes
  73. - **Minimal Impact** - Only touch what's necessary
  74. ## Compatibility
  75. Works with any [Agent Skills](https://agentskills.io)-compatible agent:
  76. - Claude Code
  77. - Cursor
  78. - GitHub Copilot
  79. - Gemini CLI
  80. - And [many more](https://agentskills.io)
  81. ## License
  82. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.