Implementer Hub

1. Read the implementation plan and extract the full list of files to be created or modified.
2. Run git --no-pager diff --name-only HEAD~5 to check for in-flight changes that might conflict with the plan.
3. Group the file list into modules by directory (e.g., src/auth/, src/api/, src/db/). Create a module partition table: | Module | Files | Dependencies | Priority |.
4. Identify cross-cutting concerns by searching for shared types or interfaces: run grep -rn 'export type\|export interface' <target-dirs> | head -30 to find shared contracts.
5. Build a dependency-ordered implementation sequence: types/interfaces → data layer → service layer → API/route layer → tests. Record this as a numbered step list.
6. For each step in the sequence, identify which files change and whether they can be parallelized (no shared imports between them) or must be serial (one imports from another).
7. Dispatch each work unit to the appropriate implementer agent with: file path, planned changes, relevant context from the context bundle, and the conventions sheet.
8. After each implementer agent completes, run git --no-pager diff --stat to verify only the expected files were modified.
9. Run the project's existing lint command (extract from package.json scripts or Makefile) to catch convention violations across all changed files.
10. Run the project's test suite with npm test, pytest, cargo test, or equivalent. Record pass/fail counts.
11. If any tests fail, identify the failing test, map it back to the responsible implementer change, and re-dispatch a fix to that specific agent.
12. Compile a completion report with the full list of changes, test results, and any remaining issues.

Decision rules

• Never dispatch two agents to modify the same file simultaneously — serialize those changes.
• If a type definition changes, all downstream consumers must be updated in the same batch before tests run.
• If a new dependency is needed, add it to the manifest first (step it before any code that imports it).
• If the plan has >15 file changes, split into 2–3 sub-batches and run the test suite between batches.
• If an agent reports a conflict with existing code not in the plan, pause and escalate to the user.

Output requirements

1. Module Partition Table — columns: Module, Files, Dependency Count, Execution Priority.
2. Implementation Sequence — numbered list showing the order of file changes with parallelization notes.
3. Dispatch Log — for each dispatched unit: agent, file(s), status (pending/done/failed), and duration.
4. Conflict Check — list of any merge conflicts or unexpected file modifications detected.
5. Test Results — pass/fail count, failing test names, and which change caused each failure.
6. Completion Summary — total files changed, lines added/removed, and outstanding issues.

References

• references/handoff-contract.md — inter-agent handoff format
• references/anti-patterns.md — common multi-agent coordination failures
• references/success-criteria.md — completion verification standards

Related skills

• implementer-context — provides the context bundles consumed by this skill
• implementer-node-agent — executes individual file-level changes
• planner — produces the plans this skill orchestrates
• qa-validation — validates the combined output of all implementer agents

Failure handling

• If an implementer agent fails on a file, retry once with additional context. If it fails again, mark that file as blocked and continue with independent files.
• If the test suite fails after a batch, run git stash on the batch changes, re-run tests to confirm the baseline passes, then git stash pop and bisect the failure.
• If circular dependencies between modules prevent clean ordering, identify the cycle and break it by extracting shared types into a common module first.
• If the plan references files that do not exist and are not marked as "create", flag the discrepancy and ask for plan clarification before proceeding.