VibeClaude

Vibe coding, taken entirely too literally.

Use an "extra controller" from Intiface Central and buttplug.io to connect every Claude Code action deeply with your body. A port of opencode-buttplugio to Claude Code's function hooks.

Claude Code ──hooks module──HTTP──▶ daemon ──WebSocket──▶ Intiface Central ──BLE──▶ you

Requirements

• Claude Code with function-hooks plugin support (an early-access API; built against 2.1.291)
• Node.js 22+, as node on your PATH (the buttplug client does not run on older versions)
• Intiface Central with its WebSocket server running (default ws://127.0.0.1:12345)
• A little desire
• A comfortable, private setting
• Some lubricant (optional, but strongly recommended)
• A vibration-capable "controller", paired in Intiface Central

Install

git clone https://github.com/transkatgirl/vibeclaude.git ~/.claude/vibeclaude
cd ~/.claude/vibeclaude && npm install

Then either load it for one session:

claude --plugin-dir ~/.claude/vibeclaude

or add it permanently from inside Claude Code:

/plugin marketplace add ~/.claude/vibeclaude
/plugin install vibeclaude@vibeclaude-local

Restart Claude Code. The plugin loads at session start.

The daemon runs from the directory Claude Code loads the plugin from, and needs its node_modules there. A plugin installed from a marketplace is loaded from Claude Code's own copy, which may not have them (one cloned from a git repository never does). If a toast says the "buttplug" npm package is missing, run npm install in the directory it names.

Use

1. Start Intiface Central and press the server start button.
2. In Claude Code run /intiface.
3. Select a vibration-capable device from the scan results.
4. Get comfortable, connect with your device, and slowly adjust to the feeling of becoming one with it.
5. Start enjoying your coding session.

The commands run in the plugin itself: they start no model turn, use no tokens, and leave nothing in the conversation. All four also work while a turn is running.

/intiface opens a dialog that says what it is doing (Connecting, Scanning) and then lists the devices that can vibrate, the selected one marked Connected. Move with the arrows or Tab, pick with Enter or a click, leave with Escape.

Nothing plays until a device has been selected. Exactly one device is driven at a time: it has your undivided attention, and you have its. When the first session starts, the plugin connects to Intiface and restores the previously selected device when it is available. If Intiface was not running then, each Claude Code started later tries again, unless you disconnected with /intiface-disconnect. When the last session ends, it stops the device and disconnects.

Notices such as "Restored …" or "Connection to Intiface was lost" appear as toasts, in every open session, as they happen. If the connection is lost the device is deselected; reconnect with /intiface. A device that drops off on its own is selected again when it comes back.

You can do something else while a turn runs. You do not need to watch the screen: bodily pleasure and the haze in your mind will tell you whether the task is complete.

What you feel

Every pattern is a constant intensity for a fixed time. Within a conversation only one plays at once: the most recent event wins, so your body always knows what Claude is doing right now.

Every Claude Code session you have open drives the device, each keeping track of its own tool calls, permission prompts and todos. When more than one is playing you feel the strongest of them, and when that one stops the device goes back to whatever the others are still playing: a pulse from one session does not cut short an edit hold in another, and ending or interrupting one session stops only its own output.

A subagent is felt like the conversation that started it: its thinking and text as they stream, a response that arrives whole, its tool calls, its permission prompts and its todos. It is mixed with that conversation, and with any other subagent at work, the way another session is: you feel the strongest of them, and a pulse from one does not cut short an edit hold, or the pulses of the turn ending, in another. The end of a subagent's run is not the end of the turn: it is felt as a tool call's result, and for a subagent in the foreground it lands together with the result of the call that started it. One that is interrupted with its turn is felt as the turn ending, whose three pulses take the place of its result. One in the background plays on after the turn has ended or been interrupted, until its own run does; ending the session stops them all. While a permission prompt waits, thinking and text are held back in the whole of its session, so that whatever else is still streaming does not fill the pauses that give the prompt its rhythm; tool calls and edit holds still come through.

Too much, or saving yourself for later? /intiface-intensity 0.5 halves everything. The intensity is one multiplier for the whole daemon, applied last: every session and subagent plays its patterns as the table has them, the strongest is picked, and that is what gets multiplied. It starts at 1.0 (every pattern as written), takes effect at once, whatever is playing included, and is remembered until you change it. At 0 nothing is felt; anything above it still is, since a faint level rounds up to the device's weakest step, never down to nothing.

Turn completion, permission requests, interruptions, completed todos... you no longer need a separate notification plugin. Now you can feel it all with your body, as though Claude Code has become one with you.

Three things are approximations, because of what Claude Code tells a plugin:

• Thinking. Claude Code hands a plugin thinking's text only where it is shown to someone. Where it is withheld (a headless claude -p run is one such place), thinking is not felt.
• Answering a permission prompt. Claude Code draws the prompt itself and does not say when it was answered. The pattern stops when the tool that asked finishes or fails, or when you reject it. So after you approve a call that takes a while, the pattern goes on until the call is done. The one earlier sign is the run-in-background hint Claude Code draws under a long-running command a moment after it starts: that stops the pattern too, but only in the terminal, and where several commands share one hint, only for the first of them. A subagent's prompt also stops when the subagent's run ends. Other tool calls running alongside do not silence it.
• Tool output. Nothing reports a command's output as it is printed, so it is not felt: a tool's result is its one pulse.

Worn out? Output stops automatically when you switch devices, end the session, disconnect, lose the Intiface connection, or the daemon exits. After intense "coding," a rest may be in order.

Configure

Claude Code asks for the plugin's options when you enable it; change them later under /plugin → manage.

A new address takes effect when the daemon next starts: end your sessions, or run node daemon/daemon.mjs stop and let the next event start it again.

The selected device, the intensity and daemon.log are kept in ~/.config/vibeclaude. If TCP port 12350 is taken on your machine, a config.json there containing { "port": 12351 } moves the daemon.

How it works

hooks/register.tsx is a hooks module: it runs inside Claude Code, where it sees the model's response as it streams (turn.step), each tool call from start to finish (tool.call), permission checks, subagents being started (agent.spawn), and turns and sessions beginning and ending, in the conversation and in each subagent's own loop. It reduces each to a tiny event (sizes and identifiers, not text) and posts them, in order, to the daemon on `127.0.0.1:1235