- Home
- Skills
- Agents & Orchestration
- multi session tdd plans
Works with the AI Agents you already use
multi session tdd plans
A formal TDD planning and execution framework for large features that span multiple agent sessions.
$9
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
| Session | Type | Scope | Verification |
|---|---|---|---|
| 1. Foundation | [Sequential] | src/billing/client.py, tests/unit/test_client.py | pytest tests/unit/test_client.py |
| 2. Webhooks | [Parallel] | src/api/webhooks.py, src/billing/handlers.py | curl -X POST localhost:8000/webhooks/stripe |
| 3. Subscription | [Sequential] | src/models/user.py, src/services/subscription.py | pytest tests/integration/test_billing_flow.py |
| 4. Audit/Wiring | [Gate] | All touched files, Production entry points | Full suite + Linter |
Session 1 Execution: Client Foundation
I am now executing Session 1.
- LOAD: Initialized
docs/STATUS.md. - PLAN: Creating Stripe API wrapper. Files:
src/billing/client.py. - TEST: Wrote
test_client_initializationandtest_request_retry(Red). - BUILD: Implemented
StripeClientwith exponential backoff (Green). - VERIFY: Unit tests passed. Linter clean.
Audit Summary: Session 1
| # | Specified | Implemented | Gap |
|---|---|---|---|
| 1 | Client retry logic | Exponential backoff | None |
| 2 | Secret management | Environment variable lookup | None |
| 3 | Unit tests | 4 scenarios covered | None |
Next steps
- Review the generated plan in
docs/plans/2023-10-27-stripe-billing.md. - Approve the handoff in
docs/STATUS.md. - Invoke
execute docs/plans/2023-10-27-stripe-billing.md session 2to 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
- Write Phase uses the
plan-template.mdto generate a structured implementation roadmap indocs/plans/. - Execution Phase follows the nine-step lifecycle (Load, Plan, Test, Build, Refine, Review, Verify, Audit, Handoff).
- Audit Phase generates a gap table in
docs/audits/to ensure 100% compliance with the session's acceptance criteria. - Handoff updates a persistent
docs/STATUS.mdfile 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.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
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
- Software
Git