Orchestrator Skill

Decompose large specifications into atomic implementation tasks with dependencies and acceptance criteria.

4|1|Updated Oct 8, 2025
One-click install
npx skills add https://github.com/deMGoncalves/arq-specs-template --skill orchestrator-skill
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Orchestrator Skill
Source: https://github.com/deMGoncalves/arq-specs-template/tree/main/.claude/skills/orchestrator
Command: npx skills add https://github.com/deMGoncalves/arq-specs-template --skill orchestrator-skill

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents AI hallucinations and ensures deterministic code generation by breaking down large, complex specifications (5000+ lines) into small, atomic implementation tasks (under 100 LOC each). This is critical for maintaining AI focus and producing correct code.

Core Features & Use Cases

  • Atomic Task Decomposition: Transforms vast specifications into manageable tasks, each with a limited context (~500 lines) to guide AI development precisely.
  • Dependency Management: Automatically establishes explicit dependencies between tasks, ensuring a logical and correct implementation order.
  • BDD & DDD Integration: Maps BDD scenarios to Domain-Driven Design components, generating tasks that directly address business behavior and architectural patterns.
  • Use Case: When faced with a new feature requiring extensive changes, this Skill automatically generates a detailed tasks.md breakdown, allowing developers to implement the feature step-by-step with minimal risk of AI misinterpretation.

Quick Start

To start a new workflow for "Implement JWT authentication", invoke the Orchestrator: @skill orchestrator /workflow start "Implementar autenticação JWT"

Frequently Asked Questions about Orchestrator Skill

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

FAQPage Schema
How do I break down large specifications into smaller tasks for AI implementation?

Task decomposition breaks multi-thousand-line specs into atomic tasks under 100 LOC each, with ~500 lines of context per task. This prevents AI hallucinations by narrowing focus and establishing explicit dependencies, ensuring deterministic code generation across discovery, architecture, and specification phases.

What's the best way to prevent AI hallucinations when generating code from complex requirements?

Atomic task decomposition with explicit dependencies and acceptance criteria prevents hallucinations by constraining AI context to ~500 lines and limiting task scope to under 100 LOC. Phase-ordered execution and dependency mapping ensure logical implementation order and correct behavior.

Can I use BDD and DDD patterns with task decomposition for feature implementation?

Yes. Task decomposition maps BDD scenarios to Domain-Driven Design components, generating tasks that address business behavior and architectural patterns. This integration ensures tasks align with both behavioral requirements and domain structure.

How do I organize dependencies between implementation tasks?

Decomposition automatically establishes explicit task dependencies and outputs a `tasks.md` file with phase metadata and context-loading guidance. This ordering ensures tasks execute in a logically correct sequence that respects architectural constraints.

When should I use task decomposition instead of implementing features directly?

Use decomposition for features requiring extensive changes, large specifications (5000+ lines), or high-complexity requirements where AI focus and correctness are critical. It's especially valuable when implementation spans multiple phases or involves multiple architectural components.

What output does task decomposition produce for my development workflow?

Decomposition produces `changes/[change-id]/tasks.md` with phase-ordered atomic tasks, explicit dependencies, acceptance criteria, and context constraints. Each task includes guidance for loading relevant code sections, enabling step-by-step implementation with minimal AI misinterpretation risk.