Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    devflow plan

    1

    Stop jumping straight into code only to find breaking changes or missing edge cases halfway through.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    devflow plan

    devflow plan

    Example session with this skill installed

    Plan a bug fix for the authentication timeout issue on the auth-fix branch. It seems to happen when the token expires during a transition.

    • Read your context and instructions
    • Compiled the devflow plan

    I have researched the authentication flow and identified the race condition during token expiration. I ran the plan critic to verify that the proposed changes to the useAuth hook won't break the session provider.

    Implementation Plan: auth-fix

    ---
    type: bugfix
    status: approved
    created: 2024-05-20
    ---
    
    # Bug Fix: Authentication Timeout during Transition
    
    ## Context
    - Source: `src/hooks/useAuth.ts`
    - Source: `src/providers/SessionProvider.tsx`
    - Issue: Token refresh logic triggers a logout if a route transition occurs before the new token is stored.
    
    ## Requirements
    - R1: Prevent `onLogout` trigger during active `isRefreshing` state.
    - R2: Queue route transitions during token refresh.
    
    ## Root Cause Analysis
    - The `useEffect` in `useAuth` lacks a debounce or lock mechanism, causing redundant refresh calls during navigation.
    
    ## Tasks
    - T1: Add `isRefreshing` ref to `useAuth.ts`.
    - T2: Update `SessionProvider` to expose refresh status.
    - T3: Add regression test in `tests/auth/refresh.test.ts` mocking slow network.
    
    ## Plan review notes
    - FIXED: Critic identified that T1 was missing a cleanup function for the refresh timeout.
    - USER DECISION: Should we increase the default timeout from 5s to 10s?
    

    Next steps

    1. Review the plan details above.
    2. I have saved this to docs/plan/auth-fix.md.
    3. Give me the go-ahead to start implementation of T1.

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

    About this skill

    Stop jumping straight into code only to find breaking changes or missing edge cases halfway through. This skill enforces a rigorous planning phase for every ticket, bug fix, or refactor before a single line of implementation logic is written. It ensures that technical debt and architectural gaps are identified by an automated critic before they reach your PR.

    What it does

    • Branch management validates your current git branch and ensures work is scoped to feature or fix branches rather than protected ones.
    • Root cause analysis requires evidence-backed findings for bug fixes and mandates regression test planning.
    • Automated plan criticism uses a subagent to independently audit your plan for breaking changes, contract violations, and missing dependencies.
    • Structured documentation generates implementation plans with numbered requirements and tasks following a strict internal schema.
    • Epic synchronization tracks the status of individual ticket plans within larger epic documents to maintain project visibility.

    How it works

    1. Context discovery identifies if you are starting a new task, expanding an epic stub, or revising an existing approved plan.
    2. Narrow research analyzes the specific files, shared libraries, and exported APIs affected by the proposed change.
    3. Independent audit triggers a critic subagent to verify risky claims and surface potential regressions in the draft.
    4. User approval presents the final audited plan for your sign-off, ensuring the path forward is clear.
    5. Persistent storage saves the approved plan to a local docs/plan/ directory (git-ignored) for use by implementation and review agents.

    Frameworks & tools

    Built for environments with Git and Bash. Optimized for agents with subagent capabilities like Claude Code or Cursor, using independent LLM instances for the critic phase.

    Why this beats prompting it yourself

    Standard prompts often suffer from "happy path" bias where the agent ignores side effects to please the user. This skill forces a distinct "Critic" role to run via a subagent, providing a objective secondary check that manual prompting rarely achieves.

    Use cases

    • Planning a complex refactor with safety-net tests and ordered migration steps.
    • Investigating a bug to document the confirmed root cause before writing a fix.
    • Expanding a high-level epic stub into a detailed, implementable ticket.
    • Verifying if a change to a shared library will break downstream consumers.

    Known limitations

    Requires a Git repository to function. Plans are stored locally in docs/plan/ and are not automatically committed to version control.

    Requires a Git repository. Plan files are saved locally and must be manually excluded from commits. Works best with agents capable of spawning subagents for the critic phase.

    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
    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill enforces a mandatory 'Critic' phase where a separate subagent audits your plan for breaking changes and architectural gaps, preventing the 'happy path' bias common in standard LLM prompts.

    The skill is optimized for agents with subagent capabilities like Claude Code or Cursor, and requires a Git-initialized repository and a Bash-compatible environment to function.

    Plans are saved locally to a git-ignored `docs/plan/` directory, ensuring your implementation agents have a persistent source of truth without cluttering your remote repository history.

    Yes, the 'Epic synchronization' feature allows you to track individual ticket plans within a larger epic document, ensuring all sub-tasks remain aligned with the broader project goals.

    You receive the full skill definition and configuration files required to integrate the planning and critic workflows into your supported AI agent environment.

    While it performs deep research into affected files and APIs, the skill does not automatically commit code or push changes, keeping the final implementation control entirely in your hands.

    New in Code Quality & Review