feature-sliced-design

Organize frontend code into layers and slices with downward dependency rules.

Updated Feb 12, 2026
One-click install
npx skills add https://github.com/lucas-martino/ai-augmented-development-agents --skill feature-sliced-design-lucas-martino
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: feature-sliced-design
Source: https://github.com/lucas-martino/ai-augmented-development-agents/tree/main/skills/feature-sliced-design
Command: npx skills add https://github.com/lucas-martino/ai-augmented-development-agents --skill feature-sliced-design-lucas-martino

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill provides a methodology to address the complexity and maintainability issues of large-scale frontend applications.

Core Features & Use Cases

  • Scope-based Decomposition: Organizes code into slices that align with business value and technical layers.
  • Layered Hierarchy: Defines a strict downward dependency rule for code organization.
  • Public API & Slice Isolation: Ensures that each slice is self-contained and does not depend on others at the same layer.

Quick Start

Initialize the feature-sliced design by organizing your code into layers and slices following the provided guidelines.

Frequently Asked Questions about feature-sliced-design

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is scope-based decomposition in frontend architecture?

Scope-based decomposition organizes frontend code into slices that align with business value and technical layers. This architectural methodology enforces downward dependency rules and strict isolation between slices to solve large-scale application complexity.

How do I structure a large frontend application for maintainability?

Structure a large frontend application using a layered hierarchy with strict downward dependency rules. Organize code into isolated slices, enforce mandatory public API exports, and align modules with business value to ensure long-term maintainability.

When do I need a layered architecture for my frontend project?

You need a layered architecture when frontend scalability becomes critical and code complexity impacts maintainability. Scope-based decomposition aligns technical layers with business value, enforcing isolation and downward dependencies to manage large-scale application growth effectively.

How to enforce strict isolation between code slices in frontend?

Enforce strict isolation between code slices by mandating public API exports for each slice. Ensure slices at the same layer remain self-contained and do not depend on each other, adhering to the downward dependency rules of the layered hierarchy.

Does feature-sliced design work for existing frontend codebases?

Feature-sliced design works for existing frontend codebases by incrementally organizing code into layers and slices following the provided guidelines. The methodology aligns existing code with business value and technical layers without requiring a complete rewrite.

What are the limitations of scope-based decomposition for frontend scaling?

Scope-based decomposition requires strict adherence to downward dependency rules and mandatory public API exports. The methodology introduces structural overhead and may complicate small projects where the overhead of slice isolation and layered hierarchy outweighs maintainability benefits.