- Home
- Skills
- Agents & Orchestration
- feature driven development
feature driven development
Organize codebase into isolated, end-to-end vertical slices following Feature-Driven Development (FDD) principles.
Free
Works with the AI Agents you already use
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
| Layer | Responsibility | Path Location |
|---|---|---|
| Domain | Billing models, subscription types, and repository contracts | src/features/user-billing/domain/ |
| Infrastructure | Stripe API adapters and billing repository implementations | src/features/user-billing/infrastructure/ |
| Presentation | Billing templates, subscription hooks, and local UI state | src/features/user-billing/presentation/ |
| Orchestration | Routing-only page wrapper for the billing dashboard | src/pages/settings/billing.tsx |
| Commons | Currency formatting and generic price display primitives | src/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
UserBillingTemplateand its internal molecules (e.g.,PlanSelector). - Define the API adapter in the infrastructure layer to handle external billing webhooks.
billing.tsx
ZIP · project files
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/pagesfocused 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/commonsorsrc/commons-ui.
How it works
- Define the boundary by identifying the user-visible slice and checking for existing Figma surfaces or repo patterns.
- Layer the logic by distributing responsibilities across domain models, infrastructure adapters, and presentation components.
- Compose the screen by creating a feature
Templateand wiring it into a routing-only page file. - 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.
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
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 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
Free forever
No account required to browse
Trust & safety
Security scan
Security scan passed 15 days ago
- Free with an Agensi account