Plan Decompose Orchestrate

    1

    Turn a flat plan into a dependency graph of small, test-first tasks before any code is touched.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Plan Decompose Orchestrate

    Example session with this skill installed

    I need to add a Redis cache and an API rate-limiter to our backend. วางแผนก่อน.

    • Read your context and instructions
    • Compiled the plan decompose orchestrate

    I will decompose this into a task graph with an orchestration shape of

    Parallel for the initial implementations, as the cache and rate-limiter reside in different modules.

    Orchestration Plan: API Enhancements

    TaskImplementTestReview
    A. Redis CacheAdd RedisCache decorator to GET /dataVerify cache hit/miss latency and TTL expiration1. Spec: Cache hit reduces DB load. 2. Quality: Connection pooling check.
    B. Rate LimiterImplement FixedWindow middleware in auth.tsSimulation of 101 requests/min triggering 4291. Spec: 429 returned on limit. 2. Quality: Memory leak check on keys.

    Orchestration Shape: Parallel

    • Item A and B touch different files (/services/cache.ts vs /middleware/auth.ts).
    • I will use isolated worktrees to execute these concurrently.
    • If any test fails, I will halt and initiate a deep-down root-cause analysis.

    Next steps

    1. Approve the decomposition triad above.
    2. I will initialize the RedisCache implementation using a TDD approach.
    3. Parallel execution will begin once the test environment is verified.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop shipping code that breaks in production because a step was rushed or a dependency was missed. This skill transforms flat to-do lists into high-integrity execution graphs by enforcing a strict implement-test-review triad for every single task. It eliminates the "it works on my machine" syndrome by requiring deterministic reproduction and root-cause analysis for every bug.

    What it does

    • Plan decomposition breaks every task into an explicit Implement, Test, and Review triad to ensure 100% completion.
    • Dependency mapping analyzes task relationships to determine the optimal parallel or sequential execution shape.
    • Deep-down debugging follows a 7-step root-cause protocol that prevents patching symptoms and stops recurring bugs.
    • Two-pass review validates both functional spec-compliance and underlying code quality for every change.
    • Orchestration management identifies when to use git worktrees for isolated parallel development to prevent file clobbering.

    How it works

    1. Trigger the skill by asking to "plan first" or "วางแผนก่อน" before starting any multi-file implementation.
    2. Decompose the initial requirements into the implementation-test-review triad, mapping each to actual source code.
    3. Orchestrate the execution by defining which tasks run in parallel and which require sequential pipelines.
    4. Execute the plan, switching to the root-cause debugging protocol immediately if any test fails.

    Frameworks & tools

    Works with any language or framework. It integrates with git for worktree isolation and standard testing runners for deterministic validation.

    Why this beats prompting it yourself

    Standard LLM plans are usually just a list of features to build. This skill forces the agent to define how it will prove the code works and how it will review its own quality before a single line of code is written, drastically reducing technical debt.

    Use cases

    • Migrating complex logic across 2+ files where state dependencies are high.
    • Investigating intermittent or flaky test failures that require a systematic trace.
    • Designing new features from scratch using a TDD (Test-Driven Development) workflow.
    • Managing multi-agent task distribution where parallel work might conflict.

    Known limitations

    Not recommended for trivial one-line edits or purely informational queries. Requires access to the codebase to verify signatures before planning.

    Requires access to existing code to avoid planning against assumed structures. Not intended for simple one-line changes or non-coding questions.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    • Free with an Agensi account

    Permissions

    Read Files
    Listed28 days ago
    Updated25 days ago

    What's inside

    Frequently Asked Questions

    While standard prompts provide a list of steps, this skill enforces a strict "Implement-Test-Review" triad for every task, ensuring that no code is marked complete until it is verified and peer-reviewed by the agent. It proactively maps dependencies to prevent the common logic errors that occur when AI agents rush through sequential tasks.

    This skill is platform-agnostic and compatible with any AI agent that has file-system access and a terminal. It is optimized for environments where the agent can utilize git and language-specific test runners to validate its own work.

    The skill uses a 7-step root-cause protocol that moves beyond surface-level fixes by requiring the agent to reproduce the bug deterministically before attempting a solution. If a test fails during execution, the agent automatically pivots to this debugging mode to identify and fix the underlying issue rather than just patching the symptom.

    Yes, the orchestration layer is designed to manage complex, multi-file changes by utilizing git worktrees. This allows the agent to isolate parallel development tasks, preventing the file clobbering and state conflicts that typically occur when an agent tries to edit multiple dependent files at once.

    You receive the complete orchestration logic, the structured plan-decomposition templates, and the 7-step root-cause debugging protocol. The package also includes documentation on how to trigger the 'plan first' workflow and integrate it into your existing agentic routines.

    New in Agents & Orchestration