Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    devflow epic

    1

    Turns a PRD, TDD, designs or a prompt into an epic plus ordered tickets, each with a branch name and a stub plan. A critic checks coverage, dependencies and breaking changes before you review it.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    devflow epic

    devflow epic

    Example session with this skill installed

    Break down the new auth-service PRD in docs/rfcs/auth.md into tickets for a new epic called 'user-auth-migration'.

    • Read your context and instructions
    • Compiled the devflow epic

    I have analyzed docs/rfcs/auth.md and researched the existing identity-provider package. A draft epic has been created and verified by the plan critic.

    Epic: user-auth-migration

    TicketBranchTypeDescription
    T-1feat/auth-schemamigrationDefine new Postgres schema for user sessions
    T-2feat/auth-api-contractcontractExport session validation types in shared-types
    T-3feat/auth-service-logiclogicImplement JWT rotation in auth-service
    T-4feat/auth-ui-integrationuiUpdate login component to use new auth-service endpoints

    Analysis Summary

    • Sources: docs/rfcs/auth.md, packages/identity-provider/src/**
    • Risks: High risk on T-1; session migration must be backward compatible.
    • Decisions: Using JWT instead of opaque tokens to reduce DB lookups.

    Next steps

    1. Review the full epic details in the plan mode buffer.
    2. Approve the plan to generate the epic.md and 4 ticket stubs.
    3. Start the first ticket by running git switch -c feat/auth-schema.

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

    About this skill

    Manually breaking a massive feature into implementation tickets is prone to dependency deadlocks and missed edge cases. This skill automates the transition from high-level PRDs and designs into a validated, ordered execution plan.

    What it does

    • Source analysis reads PRDs, TDDs, design files, and folder contexts to understand requirements.
    • Dependency mapping orders tickets so that API contracts and migrations land before dependent UI work.
    • Automated critique uses a subagent to check the draft for coverage gaps, breaking changes, and technical risks.
    • Branch management generates unique branch names for every ticket and verifies they do not collide with existing work.
    • Ticket scaffolding creates stub plans for every task, ready to be expanded into full implementation steps later.

    How it works

    1. Input gathering where you provide the epic's scope via a prompt or reference files like PRD.md.
    2. Contextual research to identify affected services, existing patterns, and shared contracts.
    3. Epic drafting following a strict format that includes requirements tracing and a ticket table.
    4. Validation pass where an independent critic agent audits the plan against a comprehensive checklist.
    5. Final persistence saving the approved epic and individual ticket stubs to docs/plan/.

    Frameworks & tools

    This skill requires git and bash. It is designed for agents with plan modes and subagent capabilities like Claude Code, using local scripts to verify branch availability and find existing plans.

    Why this beats prompting it yourself

    Generic prompts often miss cross-package dependencies or create tickets that are too large to review. This skill enforces a "critic" loop using a separate subagent context, ensuring a cold-eyed review of your architecture before a single line of code is written.

    Use cases

    • Decompose a 10-page PRD into a sequence of atomic, shippable PRs.
    • Plan a feature that spans multiple microservices or monorepo packages.
    • Ensure breaking API changes are ticketed and merged before frontend consumers.
    • Create a standardized planning history in your repo without polluting git history.

    Known limitations

    Does not automatically create git branches or commit files. Requires a manual approval step before any files are written to disk.

    Requires git and bash. Does not create branches or commit files. Works best in agents supporting subagents and plan modes.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed today

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill is optimized for AI agents with plan-mode capabilities and subagent support, such as Claude Code. It utilizes local bash and git environments to verify branch availability and project context.

    Unlike basic prompts, this skill uses a multi-step "critic" loop where an independent subagent audits the plan for technical risks and dependency deadlocks. This ensures your tickets are execution-ready and ordered correctly, preventing the "missing piece" errors common in generic AI outputs.

    The skill outputs a structured epic document and individual ticket stubs to a `docs/plan/` directory in your repository. This creates a standardized, version-controlled planning history that your team (or other AI agents) can reference throughout the development lifecycle.

    Setup is minimal, requiring only `git` and `bash` in your local environment. Once the skill is added to your agent's toolkit, it can immediately begin reading your project files and PRDs to generate implementation plans.

    Yes, the skill is designed to handle multi-package projects and monorepos by identifying shared contracts and cross-service dependencies. It ensures that backend migrations or API changes are sequenced to land before the dependent frontend work.