Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Senior Planner

    1

    Transforms software architecture into atomic, TDD-ready implementation tasks with strict review boundaries.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Senior Planner

    Senior Planner

    Example session with this skill installed

    Plan the implementation for Project Phoenix. Architecture is at docs/arch.md, infra at docs/infra.md, and P0 stories at docs/reqs.md. The goal is a local-first CLI for log parsing.

    • Read your context and instructions
    • Compiled the senior planner

    Handoff processed for Project Phoenix. I have inventoried the P0 behaviors and mapped them to the local-first architecture.

    Implementation Plan: Project Phoenix

    Status: READY
    P0 Coverage: 100% (3 stories)
    Task Count: 4

    Review Bar

    • No Architecture Changes: Do not add HTTP listeners, external databases, or cloud SDKs.
    • File Integrity: Modifications are strictly limited to the files list in each task.
    • TDD Mandatory: The test_first assertion must fail before implementation begins.
    • Scope Lock: No implementation of P1/P2 "Future Analytics" stories.

    Task List

    IDTitleStoryFilesTest FirstEstimate
    T-001Initialize SQLite SchemaS-01src/db/schema.sqltests/db_test.py: Table 'logs' must existS
    T-002Implement Log IngestionS-01src/db/client.pytests/db_test.py: save_log() inserts one rowM
    T-003Parse Plaintext StreamsS-02src/parser/core.pytests/parse_test.py: Regex handles ISO-8601M
    T-004CLI Output TableS-03src/cli/main.pytests/ui_test.py: Output contains 'Timestamp' headerS

    Out of Slice

    • Web Dashboard (P1)
    • Multi-user authentication (Will-not-build)

    Next steps

    1. Review the plans/tasks.md file for dependency logic.
    2. Initialize the repository with the defined folder structure.
    3. Assign T-001 to a junior-tdd agent or developer.

    implemented: no
    tests_written: no

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

    About this skill

    The problem

    Vague software architectures lead to bloated junior tasks, scope creep, and architectural drift. Developers often waste time debating implementation details during sprints because the handoff lacked specific file boundaries and test-first requirements.

    What it does

    • Converts software architecture and requirements into atomic, junior-sized implementation tasks.
    • Maps every P0 story to specific file paths, avoiding "the usual places" ambiguity.
    • Defines a strict review bar that explicitly forbids architectural changes and out-of-scope work.
    • Sequences tasks by dependency (storage before UI) with realistic S/M session estimates.
    • Enforces test-first assertions for every task to ensure measurable completion.

    Why this beats prompting it yourself

    Generic prompts often hallucinate new features or ignore architectural constraints. This skill uses a strict binding process that halts execution if the architecture is blocked, preventing the creation of a "wish list" disguised as a plan. It ensures zero architectural drift by refusing to add stubs, APIs, or stores not defined by the architect.

    Use cases

    • Slicing a new feature architecture into a TDD-ready task list for a junior dev or agent.
    • Creating a dependency-aware roadmap for a P0 product launch.
    • Setting a quality gate for contractors by defining "must-not" implementation boundaries.

    Known limitations

    Requires pre-existing architecture, infrastructure, and requirement documents. It will not generate tasks for P1/P2 features or invent solutions for missing architectural components.

    Requires architecture, infra, and requirements docs to be 'ready'. Does not write code or tests. Only plans P0 stories. Will block if tasks require stack changes.

    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 2 months ago

    Permissions

    Read Files
    Write Files
    Listed2 months ago

    What's inside

    Frequently Asked Questions

    Senior Planner bridges the gap between high-level architecture and actual coding by breaking complex designs into atomic, TDD-ready tasks with specific file paths and strict 'out-of-scope' boundaries. It prevents architectural drift and eliminates the ambiguity that often leads to scope creep during the development phase.

    This skill is designed to integrate with major AI coding agents and task management workflows that support markdown or JSON exports. It works best when provided with standardized architecture documents and infrastructure schemas as a baseline.

    No, Senior Planner is a 'strict binding' tool; it requires pre-defined architecture and requirements to function. It is designed to slice existing plans into executable tasks rather than brainstorming new features or filling in missing architectural gaps.

    Every purchase includes the core Senior Planner skill logic, a set of standardized templates for architectural input, and a guide on how to interpret the generated dependency-aware roadmaps. You will also receive any minor version updates and bug fixes for the duration of the support period.

    Senior Planner sequences tasks based on logical dependencies, ensuring that core infrastructure (like storage and APIs) is prioritized before UI components. Each task includes specific TDD assertions, ensuring that a developer or agent cannot mark a task as complete without passing measurable test criteria.

    New in Agents & Orchestration