Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Implementation Planning

    1

    Converts Jira context and repository investigation facts into a grounded, bounded implementation plan.

    $4.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Implementation Planning

    Implementation Planning

    Example session with this skill installed

    Create an implementation plan for JIRA-101 (Add API rate limiting) using the investigation results showing the middleware directory and config files.

    • Read your context and instructions
    • Compiled the implementation planning

    The validation of the intake context and repository investigation is complete. I have generated a bounded implementation plan grounded in the verified file paths and middleware conventions.

    Implementation Plan

    {
      "goal": "Add API rate limiting to the high-traffic /search endpoint as defined in JIRA-101.",
      "scope": "Implement a Redis-backed middleware to limit requests to 100 per minute per API key.",
      "filesToChange": [
        {
          "path": "src/middleware/auth.ts",
          "changeSummary": "Inject rate limit check after API key validation.",
          "groundedIn": "repositoryContext.inspectedFiles['src/middleware/auth.ts']"
        },
        {
          "path": "config/default.json",
          "changeSummary": "Add rate_limit_ttl and rate_limit_max keys.",
          "groundedIn": "repositoryContext.inspectedFiles['config/default.json']"
        }
      ],
      "newFilesRequired": [
        {
          "path": "src/middleware/rateLimiter.ts",
          "reason": "Existing auth middleware is strictly for identity validation; rate limiting is a distinct cross-cutting concern."
        }
      ],
      "dataSchemaConfigImpacts": [
        "New Redis key pattern: ratelimit:{apiKey}",
        "New environment variables: REDIS_URL"
      ],
      "testChanges": [
        "Update src/middleware/__tests__/auth.unit.test.ts to mock rate limiter.",
        "Create src/middleware/__tests__/rateLimiter.unit.test.ts.",
        "Add integration test in tests/api/rate_limiting.spec.ts per repository E2E convention."
      ],
      "risks": [
        "Redis downtime could block all API traffic if not handled with a fail-open strategy.",
        "Latent race conditions in incrementing counters."
      ],
      "dependencies": [
        "Redis instance availability in staging/prod"
      ],
      "migrationConsiderations": [
        "None. New config keys have defaults defined in code."
      ],
      "outOfScope": [
        "Upgrading the Redis client library.",
        "Implementing UI notifications for 429 status codes."
      ],
      "flags": [
        "public-api-change: will now return 429 Too Many Requests"
      ]
    }
    

    Next steps

    1. Review the flags regarding the 429 status code impact on public clients.
    2. Verify the REDIS_URL is available in the CI environment for the new integration tests.
    3. Initiate file edits starting with the new rateLimiter.ts middleware.

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

    About this skill

    Stop guessing where code changes should go and start planning based on verified repository state. This skill bridges the gap between a Jira ticket and the first line of code by forcing a bounded implementation plan grounded only in confirmed facts. It prevents architectural drift and "scope creep by accident" by ensuring every proposed change refers back to an inspected file or a verified convention.

    What it does

    • Goal definition summarizes the specific scope and acceptance criteria directly from the intake context.
    • Impact mapping identifies exactly which existing files and modules must change based on prior investigation.
    • New file justification requires a documented reason why existing abstractions cannot solve the requirements.
    • Testing strategy defines unit, integration, and E2E impacts following the repository's specific naming conventions.
    • Risk assessment flags destructive changes, security implications, or public API modifications for human review.

    How it works

    1. Intake analysis reads the validated Jira ticket context and the output of a repository investigation.
    2. Fact grounding maps every proposed file change to a specific verified fact or inspected path from the investigation phase.
    3. Conflict check identifies if the plan contradicts existing repository conventions or relies on unverified assumptions.
    4. Plan generation produces a JSON object containing the goal, file list, tests, risks, and out-of-scope boundaries.

    Frameworks & tools

    This skill is language agnostic and works with any codebase where a Jira intake and repository investigation have already been performed. It specifically targets structured workflows using JSON-based context objects.

    Why this beats prompting it yourself

    Prompting often leads to hallucinated file paths or "idealized" architectures that don't match your actual code. This skill enforces a "result contract" that forbids inventing paths not found during investigation.

    Use cases

    • Drafting a technical approach for a complex feature before starting a PR.
    • Identifying unintended side effects in data schemas or environment configurations.
    • Formally documenting what is out of scope to avoid mid-sprint bloat.
    • Preparing a plan for migration-heavy tasks that require backfilling data or backward compatibility.

    Known limitations

    Planning cannot proceed if the repository investigation is incomplete or contains unresolved blockers. It does not perform the actual code edits or Jira transitions.

    Only as good as the investigation it's given — if the repository context is incomplete, the plan inherits that gap rather than magically filling it. Doesn't execute anything itself — produces a plan for a separate implementation step to follow. Flags risks and migrations, but a human still makes the actual judgment call on anything flagged — this skill doesn't auto-approve or auto-block.

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

    Permissions

    No special permissions declared or detected

    Listed18 days ago

    What's inside

    Frequently Asked Questions

    This skill eliminates 'hallucinated' architectures by requiring every proposed code change to be grounded in verified repository facts, preventing agents from suggesting files or paths that don't actually exist.

    The skill requires two specific inputs: a validated Jira ticket context and the output from a prior repository investigation (such as a file tree or code search result).

    Yes, the skill is language-agnostic and works with any codebase as long as the initial repository investigation provides the necessary context in a structured format.

    The skill produces a structured JSON object that includes a scoped goal definition, a mapped file list, a testing strategy, and a clear list of out-of-scope boundaries.

    This skill focuses exclusively on the planning and grounding phase; it identifies what needs to change but does not execute code edits or update your Jira ticket status.

    This skill is designed to plug into any AI agent framework that supports JSON-based context sharing and is typically used as a middle-layer step between analysis and execution.

    New in Agents & Orchestration