React Props Proliferate. This Is the Skill That Stops It.
Every new requirement adds a prop to the parent, which propagates to the children, which needs null checks. Vercel's Composition Patterns encodes the specific patterns that stop it — not as a blog post, but as running instructions.
There's a component in most React codebases that started as a clean abstraction and became a configuration object.
It probably has 15 props. Eight of them are optional. Four of them conditionally affect each other. The type definition is 40 lines long. The component body has two nested ternaries that nobody wants to touch. The original developer wrote it cleanly. Every subsequent requirement added a prop rather than reconsidering the abstraction.
This is not a skill problem or a judgment problem. It's a gravity problem. Props are the path of least resistance for adding behavior to a component. Composition patterns — compound components, context sharing, render props — require more upfront thought, more structural awareness, and more confidence that you're not over-engineering a simple case.
The Composition Patterns skill from vercel-labs/agent-skills has 153.8K installs. That's the most-installed skill from Vercel Engineering. The number is meaningful because Vercel builds and maintains the React ecosystem tooling that a huge fraction of the web runs on. When their engineers encode architectural patterns as a skill, the patterns aren't theoretical — they're what Vercel's own teams use at scale.
What Prop Proliferation Actually Costs
The surface problem with prop-heavy components is readability. Long prop lists are hard to scan. Conditional interactions between props require reading the component body to understand. Documentation falls behind the implementation.
The deeper problem is coupling.
A component with 15 props is a component that knows about 15 different use cases. Every use case that gets added couples the component to a new consumer requirement. Change the button variant behavior, and you have to reason about all the combinations with the other 14 props. The component becomes a shared mutable surface that's hard to modify safely.
Composition patterns solve this at the structural level rather than the prop level. Compound components expose parts (Modal.Header, Modal.Body, Modal.Footer) rather than options. Context handles the shared state between parts without threading props through each layer. Render props let consumers control the output without adding a new prop for each variation.
The abstraction stays clean because the extension mechanism is composition, not configuration.
Why "Running Instructions" Matters
There are good blog posts about composition patterns. Dan Abramov wrote one. Kent C. Dodds has an excellent course section. The patterns are documented, explained, and illustrated.
The documentation hasn't solved the prop proliferation problem, because the problem doesn't occur at the point of reading a blog post. It occurs at the point of opening a component that needs a new feature and deciding whether to add a prop or restructure.
At that moment, the question is usually "how much time do I have?" and the answer is usually "not much." The prop goes in. The abstraction gets a little worse. The decision gets repeated across hundreds of PRs over the lifetime of the codebase.
A skill changes when the pattern gets applied. It can be invoked at the exact moment you're designing or modifying a component, with the context of what you're building and what the pattern should look like in your specific case. The gap between knowing a pattern and applying it consistently closes when the pattern is accessible at decision time rather than at reading time.
153.8K installs for a skill teaching composition patterns suggests that the gap between pattern knowledge and pattern application was real and widespread — and that accessing the knowledge at decision time made a significant difference.
The Scale Reason
Vercel publishing this as a skill rather than updating their documentation is an interesting editorial choice.
Documentation describes patterns. Skills apply them. At the scale Vercel operates — where their tooling runs under most of the Next.js ecosystem — the difference between documentation and a skill that applies patterns in context is significant. A developer reading the docs and a developer with an active skill that provides composition guidance while they write components are not in the same position.
The skill being the most-installed from Vercel Engineering, at 153.8K, suggests this was one of the highest-value translations from documentation to applied knowledge they've published. Which tells you something about where the documentation-to-application gap was most acute: not in understanding Next.js routing, or Vercel deployment, or React Server Components. In component architecture. In the everyday decisions about how to structure abstractions.
The prop-heavy component isn't a catastrophic failure. It's a slow degradation. 153.8K developers found a skill more effective than a blog post for stopping it.
Part of the Composition Patterns skill — compound components, context, and render props from Vercel Engineering, as running instructions.