Skip to main content
skill CX Codex

provide-inject — Vue skill for Claude Code: dependency injection guide

provide-inject teaches the agent Vue's provide() and inject() API for passing data to deeply nested components without threading props through every level.

MIT 196 installs ★ 259 updated 2026-04-15

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add PatternsDev/skills --skill provide-inject -a claude-code
Open on GitHub

What provide-inject does

The skill explains the provide/inject pattern for Vue: provide() in a parent component makes data available to all descendants, inject() in child components retrieves it directly. Useful for themes, locale, authentication state — anything many components need at once. Works at app level (app.provide()) or within the component tree.

It teaches the agent when to pick props over provide/inject: props are simpler and explicit for local data, provide/inject eliminates prop drilling in deep trees but makes debugging harder in large apps with many providers. The skill file is active for all .vue files in the project.

What it helps with

  • pass data to nested components without props at every level
  • set up shared theme, locale or auth data for the entire app
  • remove prop drilling in deep Vue component trees
  • build a plugin with data accessible to any component

Example prompts for the agent

  • Use provide/inject to pass theme data to all components in App.vue
  • Set up app.provide() for locale in main.js
  • Rewrite this component: replace prop drilling with provide/inject for auth data

How to install provide-inject

1Skills CLI (Vercel)

npx skills add PatternsDev/skills --skill provide-inject -a claude-code

2Manually: put the files in place

~/.claude/skills/provide-inject/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/provide-inject/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about provide-inject

How to install provide-inject in Claude Code?

Run npx skills add PatternsDev/skills --skill provide-inject -a claude-code, the skill will appear in ~/.claude/skills/provide-inject/SKILL.md.

What does the provide-inject skill do?

Teaches the agent Vue's provide() and inject() API for passing data to nested components without threading props through every level of the tree.

When should I avoid provide/inject?

When props are simpler and more explicit (parent-child communication), when implicit dependencies complicate isolated testing, or when Pinia is already managing shared state.

Source text

SKILL.md · MIT
---
name: provide-inject
description: Teaches Vue's provide/inject API for dependency injection across components. Use when deeply nested components need access to ancestor data without threading props through intermediate layers.
paths:
  - "**/*.vue"
license: MIT
metadata:
  author: patterns.dev
  version: "1.1"
related_skills:
  - "composables"
  - "components"
---

# Provide/Inject

When managing data between parent and child components, Vue gives us the ability to use something known as **props** to pass data down from parent to child. Props can only flow in one direction, from parent components to child components (and further down). When state changes occur on parent elements, Vue will re-render components that depend on those values.

Using props works well in most cases. However, when working in large applications with a large number of components in the component tree, props can become hard to maintain since props need to be declared in _each and every component_ in the component tree.

## When to Use

- Use this when you need to pass data through deeply nested component trees without prop drilling
- This is helpful for application-wide data like themes, locale, or authentication state

## When NOT to Use

- For parent-child communication where props are simpler, more explicit, and easier to trace
- When the implicit dependency makes components harder to test in isolation or reuse outside the provider tree
- When a state management solution (Pinia) is already in place and provides the same shared state capability

## Instructions

- Use `provide()` in a parent or ancestor component to make data available to all descendants
- Use `inject()` in child components to access provided data
- Use app-level `app.provide()` for data needed across the entire application (e.g., plugins)
- Prefer props for data isolated to a specific set of components; use provide/inject for cross-cutting concerns
- Be aware that debugging can be harder with provide/inject in large apps with many providers

## Details

When considering how data can be managed between a large number of components, it's often best to work towards a solution that allows the management of application-level state in a maintainable and manageable manner (e.g. creating a reusable store, using Pinia, etc.). We talk about this in more detail in the [State Management](/vue/state-management) guide.

However, Vue also provides a certain pattern to help avoid the need for complex prop drilling in a Vue application known as the provide/inject pattern.

### Provide/Inject

The `provide()` function in Vue allows us to pass data through a component tree without the need to _prop-drill_ (i.e., pass props down manually at every level). On the other hand, the `inject()` option is used in child components to access the provided data or methods from their parent or any ancestor component.

We'll go through a simple example to illustrate how this can be done. Suppose we have a parent component called `App` that wants to share a piece of data with its child component, `ChildComponent`. Instead of passing this data as a prop, we can use `provide()` in the parent component to make the data available to all its child components.

```html
<template>
  <div id="app">
    <ChildComponent />
  </div>
</template>

<script setup>
  import { provide } from "vue";
  import ChildComponent from "./components/ChildComponent";

  provide("data", "Data from parent!");
</script>
```

We can then access this provided data in the `ChildComponent` with the help of the `inject()` function.

```html
<template>
  <div>
    <p>{{ data }}</p>
  </div>
</template>

<script setup>
  import { inject } from "vue";

  const data = inject("data");
</script>
```

By specifying `inject("data")` in the child component (`ChildComponent`), we directly access the provided `data` value from the parent component. We then bind `data` to the template to display its value.

With provide/inject, we would notice the same behavior even if we had numerous child components within the component hierarchy tree. Data from the parent `<App />` component will be rendered in any deeply nested child component without the need to prop-drill data through every component in the tree, thanks to provide/inject!

In addition to being able to `provide()` data from a parent component, we can lift the `provide()` up to the app level as well (i.e. where we instantiate our Vue application).

```js
import { createApp } from "vue";
import App from "./App.vue";
import "./styles.css";

const app = createApp(App);

// app-level provide
app.provide("data", "Data from parent!");

app.mount("#app");
```

Since app-level provides make data available to _all_ components, they are often helpful when creating [plugins](https://vuejs.org/guide/reusability/plugins.html) — self-contained code that adds functionality to the entire Vue app.

### Props vs. provide/inject

When do we choose between props and the provide/inject pattern? Both approaches have their advantages and disadvantages.

#### With props:

- We follow a clear pattern of passing data incrementally from one level to another (advantage).
- However, if our component hierarchy tree contains a large number of components, the process of passing props data one level at a time can become cumbersome (disadvantage).

#### With provide/inject

- Child components can directly access data from parent components located multiple levels above, eliminating the need for passing down data at each level (advantage).
- However, when bugs arise, debugging can be more challenging with provide/inject. This challenge becomes more pronounced in large-scale applications with numerous different providers (disadvantage).

The provide/inject pattern is most suitable for application-wide client data, such as theme information, locale/language preferences, and user authentication details. These types of data are better managed with provide/inject since any component within the application may require access to them at any given time.

On the other hand, props are ideal when data needs to be isolated within a specific set of components only.

## Source

- [patterns.dev/vue/provide-inject](https://patterns.dev/vue/provide-inject)

### References

- [Provide / Inject | Vue Documentation](https://vuejs.org/guide/components/provide-inject.html)

© patterns.dev · MIT · PatternsDev/skills

Similar skills

All skills for Frontend and UI →

From the same set58

The whole set →
async-components Teaches the agent to load Vue components asynchronously via defineAsyncComponent(), so heavy modals and dialogs don't ship with the initial bundle. CX Codex +1 207installs container-presentational Teaches the container/presentational pattern for Vue components: containers fetch data, presentational components render it via props without touching state. CX Codex +1 205installs data-provider Explains Vue’s data provider pattern for moving fetch and state logic into a renderless component with scoped slot props. CX Codex +1 204installs state-management Guides the coding agent through Vue 3 state management patterns. Helps decide between props, simple reactive() stores, and Pinia. CX Codex +1 201installs dynamic-components dynamic-components teaches switching Vue components at runtime through the reserved <component> element and its is attribute. Handy for tabbed views that don't need a router. CX Codex +1 198installs render-functions render-functions teaches your AI assistant to build dynamic Vue components using the h() render function and JSX. Useful for component libraries when standard templates become too restrictive. CX Codex +1 196installs script-setup Teaches the agent to write Vue 3 components with <script setup> — no boilerplate, no explicit return. CX Codex +1 195installs renderless-components renderless-components teaches the renderless component pattern in Vue: encapsulate logic, let consumers control markup via scoped slots. CX Codex +1 194installs

Project sponsors

Companies that keep this analytics open