planning and task breakdown

    1

    Decompose complex requirements into small, verifiable vertical slices with explicit dependency mapping and checkpoints.

    Free

    2 usesSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    planning and task breakdown

    Example session with this skill installed

    I need to add a user profile page where users can update their bio and avatar. Here is the existing User schema and API structure. Break this down into an implementation plan.

    • Read your context and instructions
    • Compiled the planning and task

    I have analyzed the requirements for the user profile feature. I will now create the implementation plan and task list.

    Implementation Plan: User Profile Management

    Overview
    Enable users to manage their public-facing identity by updating their bio (text) and avatar (image URL). This involves extending the API for partial updates and creating a dedicated settings UI.

    Architecture Decisions

    • Use HTTP PATCH for profile updates to allow partial bio/avatar changes.
    • Implement client-side image validation for avatar URLs before submission.

    Task List

    Task 1: API Update for Profile Fields

    • Description: Add bio and avatar fields to the user update endpoint logic.
    • Acceptance criteria:
      • API accepts PATCH /api/user with bio and avatar strings.
      • Database updates correctly for both fields.
    • Verification:
      • Tests pass: npm test api/user
      • Manual check: Verify DB entry via CLI after request.
    • Dependencies: None
    • Estimated scope: Small (2 files)

    Task 2: Profile Settings UI Component

    • Description: Build the form UI for bio text and avatar URL input.
    • Acceptance criteria:
      • Form displays current user data on load.
      • Submit button is disabled if no changes are made.
    • Verification:
      • Build succeeds: npm run build
      • Manual check: Render component in storybook/dev.
    • Dependencies: Task 1
    • Estimated scope: Medium (3 files)

    Task 3: Integration and Toast Notifications

    • Description: Wire the UI to the API and add success/error feedback.
    • Acceptance criteria:
      • Successful save shows a "Profile updated" toast.
      • Network errors display a specific error message.
    • Verification:
      • Tests pass: npm test e2e/profile
    • Dependencies: Task 2
    • Estimated scope: Small (2 files)

    Checkpoint: User Profile Flow

    • All tests pass
    • Profile updates persist across page reloads
    • Review UI alignment with design system

    Next steps

    1. Review tasks/plan.md for architectural alignment.
    2. Initialize Task 1 in the development environment.
    3. Confirm image storage strategy if avatar requirements change to file uploads.

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

    About this skill

    Complex features often stall when agents or developers tackle too much at once, leading to tangled code and missed edge cases. This skill enforces a systematic decomposition process, turning vague requirements into a strictly ordered graph of small, verifiable tasks.

    What it does

    • Architectural mapping identifies existing patterns, dependencies, and risks before a single line of code is written.
    • Vertical slicing ensures each task delivers a functional, testable path through the stack rather than isolated horizontal layers.
    • Dependency sequencing generates a bottom-up implementation order to ensure foundations are built before dependents.
    • Task sizing breaks work into XS-M units (under 5 files) to maximize agent reliability and focus.
    • Automated documentation generates tasks/plan.md and tasks/todo.md to maintain state across session boundaries.

    How it works

    1. Enter Plan Mode to analyze the spec and codebase in a read-only state to identify patterns and risks.
    2. Map Dependencies to visualize the relationship between schema, APIs, and UI components.
    3. Execute Vertical Slicing to group related changes into functional units rather than technical layers.
    4. Generate Task List with explicit acceptance criteria, verification steps, and file estimates.
    5. Establish Checkpoints to mandate build and test verification after every 2-3 tasks.

    Frameworks & tools

    This skill is framework-agnostic and works with any codebase using markdown-based planning or external trackers like GitHub Issues, Jira, and Linear.

    Why this beats prompting it yourself

    Standard prompts often result in "hallucinated" progress where an agent claims a feature is done despite failing builds. This skill forces a dependency-aware structure and explicit verification steps that survive context window resets.

    Use cases

    • Decomposing a high-level PRD into a multi-day implementation roadmap.
    • Splitting a large monolithic task that has become too complex for a single agent session.
    • Planning parallel work streams for multiple agents to work on independent feature slices.
    • Generating a structured task list for an external tracker like Linear or GitHub.

    Known limitations

    This skill is not for single-file hotfixes or minor config changes where the scope is obvious. It requires an existing spec or clear set of requirements to be effective.

    Requires an existing spec or requirements. Best for multi-file features, not trivial hotfixes. Task tracking defaults to markdown unless an external tracker is specified.

    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

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Read Files
    Write Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill prevents "context drift" and failed builds by forcing the agent to solve a complex feature through small, verifiable vertical slices rather than attempting to write the entire feature at once. It solves the problem of agents getting stuck in logic loops or losing track of progress during long sessions.

    The skill is framework-agnostic and designed to integrate with any agent that supports filesystem access and tool-calling, including custom-built agents and popular coding assistants that use markdown for state management.

    You receive the production-ready skill logic, a library of standardized planning templates (like `tasks/plan.md`), and a configuration guide for integrating the decomposition workflow into your existing agentic pipelines.

    Unlike a standard prompt, this skill performs an active architectural mapping of your specific codebase to identify dependencies and risks before generating a strictly ordered, bottom-up implementation graph.

    This skill is optimized for multi-file feature builds and complex refactors; it is not recommended for simple hotfixes, documentation typos, or single-file configuration changes where the overhead of formal planning exceeds the work itself.

    New in Agents & Orchestration