Skip to main content
skill CX Codex

renderless-components — Claude Code skill: what it does

renderless-components teaches the renderless component pattern in Vue: encapsulate logic, let consumers control markup via scoped slots.

MIT 194 installs ★ 259 updated 2026-04-15

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

What renderless-components does

The skill gives the agent a Vue pattern that separates logic from rendering. A renderless component holds behavior (e.g., toggling checked state) and exposes data and methods through a scoped slot, while the parent decides the UI — button, checkbox, or switch. It includes examples of a toggle component with toggle() method and checked state, reused across three different interfaces.

The skill covers .vue files and explains when composables beat renderless components in Vue 3: composables skip the extra template layer. Renderless components fit when you need a component-based API or template-level composition, for instance in a UI library. If the logic is trivial or a plain function works, the pattern adds unnecessary weight.

What it helps with

  • reuse component logic across different UI representations
  • extract state and methods into a component without hardcoded markup
  • provide a component-based API for a library
  • apply the same toggle logic to a button, checkbox, and switch

Example prompts for the agent

  • Build a renderless Toggle component with a toggle method and checked state, pass them via scoped slot
  • Wrap this form in a renderless component so validation logic lives separately from markup
  • Turn this component into a renderless one: extract the logic, leave markup to the caller

How to install renderless-components

1Skills CLI (Vercel)

npx skills add PatternsDev/skills --skill renderless-components -a claude-code

2Manually: put the files in place

~/.claude/skills/renderless-components/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/renderless-components/

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

Questions about renderless-components

How to install renderless-components in Claude Code?

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

What does renderless-components do?

It teaches a Vue pattern where components expose logic and state through scoped slots but leave rendering to the parent. Example: a toggle component with a switch method that can render as a button, checkbox, or switch.

When should I use a composable instead of a renderless component?

In Vue 3, composables avoid extra component nesting and return values more directly. Renderless components fit when you want a component-based API or template-level composition, such as in a UI library.

Source text

SKILL.md · MIT
---
name: renderless-components
description: Teaches the renderless component pattern for logic-only Vue components. Use when you want to encapsulate behavior without dictating markup, letting consumers control rendering via scoped slots.
paths:
  - "**/*.vue"
license: MIT
metadata:
  author: patterns.dev
  version: "1.1"
related_skills:
  - "composables"
  - "components"
---

# Renderless Components

## Table of Contents

- [When to Use](#when-to-use)
- [When NOT to Use](#when-not-to-use)
- [Instructions](#instructions)
- [Details](#details)
- [Source](#source)

Renderless components are a pattern in Vue that **separates the logic of a component from its presentation**. The pattern provides a way to encapsulate functionality without _dictating the visual representation of the component_. In other words, a renderless component focuses solely on the logic and behavior, while leaving the rendering to the parent component.

Renderless components are particularly useful when we need to create reusable logic that can be applied to different UI implementations. By abstracting the logic into a renderless component, we can easily reuse it in various contexts without duplicating code.

## When to Use

- Use this when you need to reuse logic across components with completely different visual representations
- This is helpful for providing a component-based API in a component library

## When NOT to Use

- When composables achieve the same logic reuse without extra component nesting (Vue 3+)
- When the renderless component wraps trivial logic that a simple function or composable handles more clearly
- When the scoped slot API becomes harder to understand than a direct composable return value

## Instructions

- Create a component that provides data and methods through a single `<slot>` with scoped slot props
- Use `v-slot` destructuring in parent components to access the provided data and methods
- Prefer composables over renderless components in Vue 3 to avoid extra component nesting
- Use renderless components when you want template-level composition or a component-based API

## Details

### Toggle, toggle, toggle

Imagine you have a toggle UI element that needs to be used in different parts of your application, but each instance may have a different visual representation. Some toggles might be displayed as buttons, while others might be checkboxes or switches.

We could just create three different toggle components, however, we can observe that each toggle element has the same logic and behavior. Each toggle has an inactive and active state that's being tracked with a component data property (e.g. `checked`). When a toggle is clicked, its component state is switched from inactive to active and vice versa (i.e. `checked = !checked`).

Right away, we can see that we can create a more reusable pattern by extracting the common logic and behavior in such a way that we don't have to repeatedly define the state and toggle methods in each individual toggle component. This is a great case to use [composables](/vue/composables) since composables will allow us to encapsulate and share the common stateful logic across the different toggle components.

**useCheckboxToggle**:

```js
import { ref } from "vue";

export function useCheckboxToggle() {
  const checkbox = ref(false);

  const toggleCheckbox = () => {
    checkbox.value = !checkbox.value;
  };

  return {
    checkbox,
    toggleCheckbox,
  };
}
```

With this composable, we can now use the `useCheckboxToggle()` function in our various toggle components to share the common state and toggle logic.

However, there's another approach we can take that leverages Vue's slot mechanism — the **renderless component** pattern.

### The Renderless Component

A renderless component in Vue is a component that encapsulates logic and provides data to its children via **scoped slots**, without rendering any markup of its own. The parent component decides how the data is presented.

Here's a simple renderless `Toggle` component:

```html
<script setup>
  import { ref } from "vue";

  const checked = ref(false);

  const toggle = () => {
    checked.value = !checked.value;
  };
</script>

<template>
  <slot :checked="checked" :toggle="toggle"></slot>
</template>
```

The `Toggle` component doesn't render any HTML of its own. It only provides data (`checked` and `toggle`) through a scoped slot. The parent component can now consume this data and render whatever UI it wants.

**Using the renderless Toggle as a button:**

```html
<template>
  <Toggle v-slot="{ checked, toggle }">
    <button @click="toggle">
      {{ checked ? "ON" : "OFF" }}
    </button>
  </Toggle>
</template>
```

**Using the renderless Toggle as a checkbox:**

```html
<template>
  <Toggle v-slot="{ checked, toggle }">
    <label>
      <input type="checkbox" :checked="checked" @change="toggle" />
      {{ checked ? "Checked" : "Unchecked" }}
    </label>
  </Toggle>
</template>
```

**Using the renderless Toggle as a switch:**

```html
<template>
  <Toggle v-slot="{ checked, toggle }">
    <div
      class="switch"
      :class="{ active: checked }"
      @click="toggle"
    >
      <div class="switch-handle"></div>
    </div>
  </Toggle>
</template>
```

In all three cases, the same `Toggle` renderless component provides the toggle logic, but the rendering is entirely different!

### Composables vs. Renderless Components

Both composables and renderless components achieve the goal of reusing logic across components. However, there are some differences:

**Composables:**
- Logic is encapsulated in a regular JavaScript function.
- Can be used directly in `<script setup>` or `setup()`.
- Don't involve any additional component layers.

**Renderless components:**
- Logic is encapsulated in a Vue component.
- Use scoped slots to pass data to children.
- Add an extra component layer in the template.

In general, composables are the preferred approach in Vue 3 since they don't add extra component nesting. However, renderless components can be useful when you want to provide a component-based API (e.g., in a component library) or when you need template-level composition.

## Source

- [patterns.dev/vue/renderless-components](https://patterns.dev/vue/renderless-components)

### References

- [Renderless Components | Vue Documentation](https://vuejs.org/guide/components/slots.html#renderless-components)
- [Composables | Vue Documentation](https://vuejs.org/guide/reusability/composables.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 provide-inject provide-inject teaches the agent Vue's provide() and inject() API for passing data to deeply nested components without threading props through every level. CX Codex +1 196installs 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

Project sponsors

Companies that keep this analytics open