Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    multi session tdd plans

    1

    A formal TDD planning and execution framework for large features that span multiple agent sessions.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    multi session tdd plans

    multi session tdd plans

    Example session with this skill installed

    I have an approved design for a new Stripe billing integration. Write a plan to implement it across the backend services and execute the first session.

    • Read your context and instructions
    • Compiled the multi session tdd

    I have initialized the implementation plan and the persistent status tracker. The plan is broken down into 4 vertical slices to ensure the billing logic is wired and tested at every stage.

    Implementation Plan: Stripe Billing Integration

    SessionTypeScopeVerification
    1. Foundation[Sequential]src/billing/client.py, tests/unit/test_client.pypytest tests/unit/test_client.py
    2. Webhooks[Parallel]src/api/webhooks.py, src/billing/handlers.pycurl -X POST localhost:8000/webhooks/stripe
    3. Subscription[Sequential]src/models/user.py, src/services/subscription.pypytest tests/integration/test_billing_flow.py
    4. Audit/Wiring[Gate]All touched files, Production entry pointsFull suite + Linter

    Session 1 Execution: Client Foundation

    I am now executing Session 1.

    1. LOAD: Initialized docs/STATUS.md.
    2. PLAN: Creating Stripe API wrapper. Files: src/billing/client.py.
    3. TEST: Wrote test_client_initialization and test_request_retry (Red).
    4. BUILD: Implemented StripeClient with exponential backoff (Green).
    5. VERIFY: Unit tests passed. Linter clean.

    Audit Summary: Session 1

    #SpecifiedImplementedGap
    1Client retry logicExponential backoffNone
    2Secret managementEnvironment variable lookupNone
    3Unit tests4 scenarios coveredNone

    Next steps

    1. Review the generated plan in docs/plans/2023-10-27-stripe-billing.md.
    2. Approve the handoff in docs/STATUS.md.
    3. Invoke execute docs/plans/2023-10-27-stripe-billing.md session 2 to proceed to Webhook implementation.

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

    About this skill

    Large-scale refactors and feature implementations often fail when AI agents lose track of the plan during context window compaction. This skill introduces a rigorous file-based planning and execution framework that ensures structural integrity across multiple sessions through a strict TDD lifecycle and mandatory audit gates.

    What it does

    • Structured Planning creates durable markdown plans that survive context resets using tables and checklists.
    • Session Orchestration breaks complex changes into 3-8 vertical slices with defined dependencies and verification commands.
    • TDD Enforcement requires a Spec-Red-Green-Traps cycle for every task, ensuring tests are written before implementation.
    • Verification Gates executes a nine-step session lifecycle including full-suite test runs and linting before closure.
    • Rigorous Auditing compares implemented code against the original plan to identify and fix gaps or partial implementations.

    How it works

    1. Write Phase uses the plan-template.md to generate a structured implementation roadmap in docs/plans/.
    2. Execution Phase follows the nine-step lifecycle (Load, Plan, Test, Build, Refine, Review, Verify, Audit, Handoff).
    3. Audit Phase generates a gap table in docs/audits/ to ensure 100% compliance with the session's acceptance criteria.
    4. Handoff updates a persistent docs/STATUS.md file to maintain state across agent restarts.

    Frameworks & tools

    This skill is stack-agnostic and works with any language including Python, TypeScript, Go, and .NET. It integrates with existing test runners, linters, and type checkers.

    Why this beats prompting it yourself

    Generic prompts often result in "partially done" states where agents leave TODOs or forget to wire new modules into production. This skill forces a file-based memory that cannot be lost to context window limits, coupled with a QA-focused audit that prevents the agent from declaring victory prematurely.

    Use cases

    • Migrating a monolithic service into separate packages or microservices.
    • Implementing complex features that span multiple layers (API, service, DB).
    • Executing large-scale codebase refactors with zero regression tolerance.
    • Managing long-running implementation tasks across multiple agent sessions.

    Known limitations

    Not intended for simple changes that fit in a single context window. Requires a pre-existing design doc and a repository structure that supports automated testing.

    Not for single-session tasks. Requires a design doc as input. Scope limited to 3-8 sessions per plan; larger tasks must be phased. Requires existing test infrastructure.

    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 11 days ago

    Requires

    Git

    Permissions

    Read Files
    Write Files
    Network Access
    Listed11 days ago

    What's inside

    Frequently Asked Questions

    This skill solves 'context drift' by moving the plan from the agent's short-term memory into persistent markdown files, using a structured TDD lifecycle to ensure the agent never loses its place or skips verification steps during multi-day tasks.

    The skill is framework-agnostic and works with any AI agent capable of file manipulation and terminal execution, including Claude Dev, Roo Code, and various autonomous coding agents.

    You receive the core TDD planning templates, the nine-step session lifecycle protocols, automated audit schemas, and a guide on how to initialize the 'docs/plans/' structure within your repository.

    While the skill works with any language (Python, TS, Go, etc.), your project must have a functioning test runner and an established directory structure where the agent can save and update its plan files.

    This skill is specifically designed for high-stakes, multi-session tasks like large refactors; for small bug fixes or single-file changes, the overhead of the formal audit gates may be more than is necessary.

    The framework is designed to be 'plug-and-play' with your existing CI/CD tools, using your project's native linting and testing commands as the mandatory verification gates for each session.

    New in Agents & Orchestration