feature driven development

    1

    Organize codebase into isolated, end-to-end vertical slices following Feature-Driven Development (FDD) principles.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    feature driven development

    Example session with this skill installed

    I need to add a new 'UserBilling' feature based on a new Figma design. How should I structure this in the repo?

    • Read your context and instructions
    • Compiled the feature driven development
    • Generated the app files

    I have mapped out the architecture for the UserBilling feature. It follows the vertical slice pattern to ensure isolation from existing user modules.

    UserBilling Feature Architecture

    LayerResponsibilityPath Location
    DomainBilling models, subscription types, and repository contractssrc/features/user-billing/domain/
    InfrastructureStripe API adapters and billing repository implementationssrc/features/user-billing/infrastructure/
    PresentationBilling templates, subscription hooks, and local UI statesrc/features/user-billing/presentation/
    OrchestrationRouting-only page wrapper for the billing dashboardsrc/pages/settings/billing.tsx
    CommonsCurrency formatting and generic price display primitivessrc/commons/

    Implementation Plan

    Feature Boundary: Since this is a new Figma surface, we are creating a dedicated user-billing slice rather than attaching it to user-profile.
    2.

    Template Extraction: The billing dashboard is a substantial screen. I will create UserBillingTemplate.tsx in presentation/templates/ to house the layout.
    3.

    Data Fetching: All SSR/ISR logic for billing cycles will live within the feature slice, keeping the route file in src/pages/ under 50 lines of code.
    4.

    Shared UI: Generic button styles or card layouts will be referenced from src/commons-ui/, while the SubscriptionCard will stay feature-local.

    Next steps

    • Generate the domain models and repository contracts for the billing entity.
    • Scaffold the UserBillingTemplate and its internal molecules (e.g., PlanSelector).
    • Define the API adapter in the infrastructure layer to handle external billing webhooks.

    billing.tsx

    ZIP · project files

    Generated

    Example file from a real run - the skill writes it into your workspace.

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

    About this skill

    Large codebases often suffer from feature creep where domain logic, UI state, and routing bleed into a tangled mess. This skill enforces Feature-Driven Development (FDD) to keep your project modular, isolated, and scalable.

    What it does

    • Enforces isolation by preventing direct feature-to-feature dependencies and requiring abstractions for collaboration.
    • Architects vertical slices by organizing code into domain, infrastructure, and presentation layers within each feature.
    • Minimizes routing bloat by keeping src/pages focused on orchestration while moving data fetching and logic into feature boundaries.
    • Governs UI composition by mandating the use of templates for substantial screens to separate layout from feature logic.
    • Manages shared logic by providing a decision framework for moving code into src/commons or src/commons-ui.

    How it works

    1. Define the boundary by identifying the user-visible slice and checking for existing Figma surfaces or repo patterns.
    2. Layer the logic by distributing responsibilities across domain models, infrastructure adapters, and presentation components.
    3. Compose the screen by creating a feature Template and wiring it into a routing-only page file.
    4. Abstract shared needs by extracting generic logic into the commons directory only when it lacks feature-specific rules.

    Frameworks & tools

    This skill is optimized for Next.js or React projects using a vertical-slice architecture. It targets stacks utilizing SSR/ISR, repository patterns, and atomic design principles (organisms, molecules).

    Why this beats prompting it yourself

    Manual prompts often result in features that "leak" into each other or bloat the pages directory. This skill follows strict structural rules for domain-driven design that prevent technical debt before it starts.

    Use cases

    • Scaffold a new end-to-end feature slice from a design requirement.
    • Refactor a bloated page file into a clean template and orchestration route.
    • Extract shared logic from two colliding features into a common abstraction.
    • Review a PR to ensure it adheres to the repo's vertical slice architecture.

    Known limitations

    Does not support monolithic "flat" folder structures. Requires a project organized with domain, infrastructure, and presentation directories.

    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.

    Requires a directory structure supporting domain, infrastructure, and presentation layers. Not suitable for flat or purely file-type-based folder architectures.

    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 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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 15 days ago

    • Free with an Agensi account

    Permissions

    Read Files
    Listed15 days ago

    What's inside

    Frequently Asked Questions

    This skill eliminates 'spaghetti code' by enforcing strict vertical boundaries, preventing features from leaking into each other and keeping your Next.js/React routing clean and scalable.

    It is specifically designed for React and Next.js environments that utilize vertical-slice architecture, Repository patterns, and Atomic Design principles.

    Yes, the skill includes a specific decision framework to help you identify when code should remain within a feature or be extracted into 'src/commons' for shared use.

    Upon purchase, you receive the full agent skill definition, including the architectural governance logic and structured workflows for scaffolding and refactoring features.

    This skill requires a directory structure that supports domain, infrastructure, and presentation layers; it will not function effectively in monolithic or 'flat' folder structures.

    The skill is designed to integrate seamlessly with leading AI coding assistants and IDE-based agents that support custom skill injections or system-level prompting.

    New in Agents & Orchestration

    Free