Chapter 6: From Vertical to Horizontal Complexity

• Completely isolate frontend presentation layer functionality from functional layer functionality
• Use Storybook for mandatory regression tests to ensure the presentation layer doesn't "quietly drift" as business iterates

The essence of this is splitting "one vertically integrated frontend page" into several more horizontal chains:

• Presentation layer: Styles, component structure, interaction details
• Functional layer: Data flow, business rules, API calls

For AI:

• Presentation layer changes can be locally understood and tested in Storybook scenarios
• Functional layer changes can be locally understood and tested in test code
• Avoids having to "understand the entire page from UI to business to backend" in one session—a deep chain

4. story-ops: Compressing Complexity to "User Stories"

https://github.com/ge-limin/story-ops is another further exploration, with the goal:

"user story = PRD = E2E test cases"

That is:

• The unit of complexity is no longer "modules" or "subsystems," but independent user stories one by one
• Each story itself contains: requirement description, expected behavior, end-to-end tests

From a complexity perspective, this is equivalent to:

• Splitting past "large and comprehensive" vertical systems into many "parallel user stories"
• Each story has its own input, output, and verification method
• AI can complete understanding and modification within the scope of one story, without having to swallow the entire system at once

5. What to Do Next

If you want your system to evolve from vertical to horizontal, consider several practical paths:

1. Identify Deep Chains:
   Find those key chains that "go from frontend all the way to the bottom layer," and see if they've already exceeded an AI session's comprehensible range.

2. Split Presentation and Function:
   Like shad-expo-studio, physically separate UI and business logic, and establish regression scenarios (like Storybook) for the UI layer.

3. Use User Stories as Segmentation Units:
   Try to make one user story carry its own "complete manual" and "complete tests," rather than relying on a lot of shared implicit state.

4. Tolerate Moderate Code Duplication:
   To make each chain independent and short enough, you must accept some implementations that "look repetitive." This is already mentioned in the "500 functions vs. 5,000 small functions" discussion.

Complexity won't disappear; it will only exist in a different form.
In the AI-native era, what we need to do is transform complexity from "vertical deep chains that are hard for both AI and humans to control" into "horizontal shallow chains that AI can eat one by one."