implementation-orchestrator

Orchestrate end-to-end implementation workflows with per-TODO worktrees and final pull requests.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/sujithatzackriya/skills --skill implementation-orchestrator-sujithatzackriya
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implementation-orchestrator
Source: https://github.com/sujithatzackriya/skills/tree/main/skills/implementation-orchestrator
Command: npx skills add https://github.com/sujithatzackriya/skills --skill implementation-orchestrator-sujithatzackriya

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This deprecated Skill automates end-to-end feature implementation by turning a requirement into a set of reviewed, test-driven changes and a final PR, without repeatedly interrupting you during execution.

Core Features & Use Cases

  • Full workflow orchestration: Plans using /tdd-workflow, drafts rich per-TODO work, executes each TODO in its own worktree, and gates each change with /think, /simplify, and /review before committing.
  • Parallelized TODO execution via worktrees: Produces one worktree and integration PR per TODO, then merges those intermediate PRs into an integration branch.
  • Final user-facing PR only: Opens a final PR to the trunk base and syncfu’s you with the URL, keeping you out of the middle steps for faster iteration.
  • Safeguarded execution rules: Includes hard rules like no questions until the final PR, no remote pushes beyond PR creation, and no destructive git operations.

Quick Start

Run the implementation orchestrator to orchestrate an autonomous implementation from requirements through the final PR ready for your review.

Frequently Asked Questions about implementation-orchestrator

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

FAQPage Schema
How do I automate a multi-step feature implementation with test-driven development and pull requests?

You can automate end-to-end feature implementation by orchestrating per-TODO work in isolated git worktrees, applying test-driven development gates, and merging intermediate changes into a final reviewed pull request. This workflow requires strict guardrails like deferred user interaction until the final PR.

What is the best way to execute multi-TODO orchestration for refactoring without monolithic pull requests?

Multi-TODO orchestration executes each refactoring step in its own isolated git worktree, producing one integration PR per TODO. Intermediate branches merge into an integration branch, culminating in a final user-facing PR rather than a single monolithic change.

Can I use isolated git worktrees to parallelize test-driven development workflows?

Yes, isolated git worktrees parallelize test-driven development by dispatching deterministic subagents per TODO. Each worktree applies think, implement, simplify, and review gates before committing, ensuring structured code review gating across parallel branches.

Does autonomous architecture execution require manual code review gating during implementation?

Autonomous architecture execution defers manual code review gating until the final pull request. During the implementation phase, it enforces hard rules like no questions until the final PR and no destructive git operations, keeping you out of intermediate steps.

Why use incremental integration branch PRs instead of committing all architecture execution changes to the trunk?

Incremental integration branch PRs prevent monolithic changes by splitting architecture execution into reviewed, test-driven TODOs. This approach safely merges intermediate worktrees into an integration branch before opening the final PR to the trunk base.

What are the limitations of autonomous implementation orchestrators for multi-step feature workflows?

Autonomous implementation orchestrators limit interaction by deferring user questions until the final PR and restricting remote pushes beyond PR creation. They also prohibit destructive git operations, requiring strict adherence to deterministic subagent dispatch rules.