lam-orchestrate

Decompose multi-file coding tasks into sub-tasks and execute them in parallel waves.

3|Updated Nov 20, 2025
One-click install
npx skills add https://github.com/sougetuOte/LivingArchitectModel --skill lam-orchestrate
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: lam-orchestrate
Source: https://github.com/sougetuOte/LivingArchitectModel/tree/main/.claude/skills/lam-orchestrate
Command: npx skills add https://github.com/sougetuOte/LivingArchitectModel --skill lam-orchestrate

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill automates the decomposition and parallel execution of complex, multi-file coding tasks, ensuring efficient and organized development workflows.

Core Features & Use Cases

  • Task Decomposition: Breaks down large user requests into smaller, manageable sub-tasks.
  • Subagent Allocation: Intelligently assigns the most suitable AI subagent to each sub-task.
  • Parallel Execution: Runs independent tasks concurrently to speed up development cycles.
  • Structured Planning: Presents a clear execution plan for user approval before starting.
  • Use Case: When asked to refactor multiple modules and update their corresponding tests, this Skill will identify all affected files, plan the refactoring and testing steps, assign appropriate agents (e.g., a refactoring agent and a test-writing agent), and execute them in parallel waves.

Quick Start

Use the lam-orchestrate skill to refactor the user authentication module and update its tests.

Frequently Asked Questions about lam-orchestrate

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

FAQPage Schema
How do I automate parallel execution for complex multi-file coding tasks?

Parallel execution for multi-file coding tasks is achieved by decomposing the request into sub-tasks and assigning specialized subagents to run concurrently. This orchestration manages task dependencies and speeds up development cycles by executing independent operations in parallel waves.

What is task decomposition in agentic AI workflow automation?

Task decomposition in agentic AI workflow automation is the process of breaking down large, complex software development requests into smaller, manageable sub-tasks. This allows specialized subagents to be intelligently allocated to each specific operation for structured execution.

How do I manage dependencies when refactoring multiple modules and updating tests?

Managing dependencies during module refactoring and test updates is handled by an orchestration framework that identifies affected files and plans execution steps. It presents a structured execution plan for approval before starting the parallel waves of development.

Can I use an Advanced Thinking framework for structured decision-making in code generation?

An Advanced Thinking (AoT) framework can be used for structured decision-making in code generation to handle complex judgments. It facilitates organized reasoning within the orchestration workflow to ensure accurate task decomposition and subagent allocation.

Does automated review loop integration work with parallel subagent execution?

Automated review loop integration works with parallel subagent execution by connecting the orchestrated coding tasks directly into review cycles. This ensures that the concurrently running subagents maintain code quality throughout the parallel waves of development.

What are the limitations of using task decomposition for software engineering workflows?

A limitation of task decomposition is the overhead required to split requests and manage dependencies for smaller projects. If the coding task does not involve multiple files or complex parallel operations, the orchestration overhead may outweigh the development cycle benefits.