Epic Decomposer

    1

    Converts engineering epics into dependency-aware task backlogs with explicit handoff contracts.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Epic Decomposer

    Example session with this skill installed

    Decompose the epic: 'Implement OAuth2 social login for GitHub and Google' into a dependency-aware task list for a React/Node.js stack. Focus on security and integration seams.

    • Read your context and instructions
    • Compiled the epic decomposer

    I have decomposed the OAuth2 social login epic into 5 structured tasks, identified integration seams, and mapped the critical path for implementation.

    Implementation Backlog: OAuth2 Social Login

    IDTask NamePrerequisitesInputsOutputsComplexity
    T1Provider App RegistrationNoneClient IDs, Redirect URIsOAuth Secrets, ScopesS
    T2Auth Middleware & StrategyT1Passport.js, App SecretsJWT Logic, Session StoreM
    T3Backend Login EndpointsT2Callback URLs, DB SchemaUser Record, Auth TokenM
    T4Frontend Auth ProviderT3API Routes, Context APIAuth State, Protected HOCM
    T5Security Audit & LoggingT2, T3OWASP ChecklistAudit Logs, Rate LimitingS

    Dependency Graph & Parallelization

    • Critical Path: T1 -> T2 -> T3 -> T4.
    • Parallel Work: T5 can begin as soon as T2 is complete, independent of frontend development.
    • Integration Seam: The handoff between T3 and T4 requires a stable JWT structure and standardized error codes.

    Risks and Decisions

    • Session Management: Using stateless JWTs to avoid Redis overhead; requires careful token revocation strategy.

    Scope Creep: Currently limited to GitHub and Google; adding more providers will require refactoring the strategy factory in T2.

    • Data Privacy: PII from social providers must be encrypted at rest in T3.

    Next steps

    1. Review the JWT structure in the handoff contract for T3/T4.
    2. Confirm redirect URIs for production and staging environments.
    3. Approve the complexity ratings before importing into the issue tracker.

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

    About this skill

    Software projects often stall when epics are too vague for direct implementation. This skill converts high-level business objectives into structured, dependency-aware task backlogs. It eliminates the ambiguity that leads to rework by defining strict handoff contracts and integration seams between features.

    What it does

    • Vertical slicing breaks epics into user-visible value increments rather than arbitrary code layers.
    • Dependency mapping builds an acyclic graph to identify parallelization boundaries and the critical path.
    • Handoff contracts define specific inputs, outputs, and touched areas for every developer-ready task.
    • Risk assessment generates a register of non-functional requirements, migrations, and observability needs.
    • Complexity scoring assigns relative S/M/L effort values without fabricating unsupported time estimates.

    How it works

    1. Provide the business outcome, system boundaries, and any known constraints or definitions of done.
    2. The skill identifies unknowns and slices the epic into logical features based on integration seams.
    3. Review the generated acyclic dependency graph to see which tasks can be parallelized safely.
    4. Export the structured backlog, complete with acceptance checks and risk profiles for each task.

    Frameworks & tools

    This tool is platform-agnostic and works with any project management stack, including Jira, GitHub Issues, or Linear. It follows vendor-neutral logic for task decomposition.

    Why this beats prompting it yourself

    Generic prompts often produce flat task lists that ignore race conditions and integration risks. This skill enforces a structured dependency DAG and explicit handoff contracts, ensuring that tasks are actually ready for implementation without further clarification.

    Use cases

    • Decomposing a monolithic feature into a sprint-ready backlog.
    • Mapping technical dependencies for a multi-agent or multi-developer team.
    • Identifying integration risks and omitted non-functional requirements in new projects.
    • Creating verifiable acceptance criteria for complex engineering epics.

    Known limitations

    Does not provide time-based estimates or schedule dates. Does not perform actual code execution or file modifications without explicit external tool access.

    Does not provide time-based estimates or schedule dates. Requires user-provided business outcomes and system boundaries to function.

    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

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    No special permissions declared or detected

    Listed1 month ago
    Updated13 days ago

    What's inside

    Frequently Asked Questions

    The Epic Decomposer specializes in generating a Directed Acyclic Graph (DAG) of tasks with strict handoff contracts, ensuring developers have clear integration boundaries and know exactly what dependencies must be met before starting.

    This skill is platform-agnostic; it generates structured data and documentation that can be easily copy-pasted or imported into Jira, Linear, GitHub Issues, or any other project management tool.

    You will receive the core logic for the decomposition engine, including the templates for vertical slicing, risk registers, and handoff contract generation, ready to be deployed within your AI agent environment.

    While the skill excels at logical sequencing and complexity scoring (S/M/L), it does not provide calendar dates or hourly estimates as these require specific knowledge of your team's velocity and headcount.

    Yes, it is specifically designed to identify 'integration seams,' making it ideal for coordinating work between multiple developers or different AI agents working on the same codebase.

    New in Agents & Orchestration