orchestrator

Decomposes approved spec.md into atomic tasks with dependencies and context limits.

Updated Dec 9, 2025
One-click install
npx skills add https://github.com/paulojoseph/next-generation-aec --skill orchestrator-paulojoseph
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: orchestrator
Source: https://github.com/paulojoseph/next-generation-aec/tree/main/.claude/skills/orchestrator
Command: npx skills add https://github.com/paulojoseph/next-generation-aec --skill orchestrator-paulojoseph

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the risk of AI hallucinations by converting large, multi-thousand line specifications into a focused set of atomic tasks that are easy to implement, verify, and maintain.

Core Features & Use Cases

  • Atomic task decomposition: Breaks down large specs into small tasks (<100 LOC) with ~500 lines of context per task.
  • BDD to DDD mapping: Transforms Given/When/Then into DDD Tactical components (Factory, Repository, Use Case, Entity, Value Objects, and Domain Events).
  • Context management & topological execution: Establishes explicit dependencies and a topological order to enable safe parallel work and predictable delivery.
  • Output artifact: Generates changes/[change-id]/tasks.md with Phase 0-4 tasks, acceptance criteria, and context guidance.

Quick Start

After a spec.md is approved, run the orchestrator to generate the tasks MD file:

  • Approve spec.md in the change, then invoke the orchestrator to create changes/[change-id]/tasks.md.
  • Load ONLY the specified context per task (to avoid hallucinations) and follow the tasks.md execution order.

Frequently Asked Questions about orchestrator

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

FAQPage Schema
How do I decompose large specifications into atomic tasks to prevent AI hallucinations?

To prevent AI hallucinations, you decompose large specifications by reading an approved spec.md, mapping BDD scenarios to DDD components, and emitting a topologically ordered tasks.md file with atomic tasks under 100 LOC and ~500 lines of context each.

How do I map BDD Given/When/Then scenarios into DDD tactical components?

You map BDD Given/When/Then scenarios into DDD tactical components by transforming them into Factories, Repositories, Use Cases, Entities, Value Objects, and Domain Events during the task decomposition process to establish explicit dependencies and topological execution order.

What is the best way to break down a multi-thousand line spec into implementation tasks?

The best way to break down a multi-thousand line spec is to generate a changes/[change-id]/tasks.md file containing Phase 0-4 tasks with strict context limits of ~500 lines, clear acceptance criteria, and explicit dependencies to enable deterministic developer progress.

Do I need an approved spec.md before generating atomic implementation tasks?

Yes, you need an approved spec.md before generating atomic implementation tasks. The decomposition process reads the approved spec.md to map BDD scenarios to DDD components and emit a topologically ordered set of tasks ready for phase-by-phase implementation.

Why does task decomposition limit context to 500 lines per task?

Task decomposition limits context to 500 lines per task to eliminate the risk of AI hallucinations, ensuring that each atomic task under 100 LOC is easy to implement, verify, and maintain without being overwhelmed by excessive surrounding specification text.

Can I parallelize implementation work when using topologically ordered task decomposition?

Yes, you can parallelize implementation work safely because topologically ordered task decomposition establishes explicit dependencies between atomic tasks, enabling safe parallel work and predictable delivery across the generated phases.