Conductor

The first physical control surface for AI-assisted coding.

Comment

Conductor is a concept for turning the Logitech MX Creative Console into the first physical control surface for AI-assisted coding. The idea is simple: the workflow developers use with AI coding tools — select code, trigger a command, wait for generation, review changed files, accept or reject — is structurally identical to the workflow that video editors, musicians, and designers already perform with physical control surfaces. Mode selection, sequential navigation, accept/reject. The MX Creative Console was built for exactly this pattern. Conductor would connect the dots — bridging Logitech's existing hardware to a 40-million-developer market that currently has zero hardware designed for how they interact with AI.

Inspiration

AI coding tools have exploded — Cursor, GitHub Copilot, Claude Code, Windsurf, Aider — but the way developers actually interact with them hasn't changed. You select code, type a prompt into a chat box, wait for generation, then click through changed files one by one with a mouse. Powerful tools, stuck behind a keyboard-and-mouse interaction model from 1984.

And the landscape is fragmenting. Most developers now use multiple AI tools in parallel — Copilot for autocomplete, Claude Code or Cursor for complex refactors, ChatGPT for architecture questions. AI agents are spawning subagents that run tasks in parallel, making changes across dozens of files simultaneously. The AI has become an orchestra. But the developer is still conducting with a text cursor, one chat window at a time.

The MX Creative Console already solves this exact interaction pattern for creative professionals. Video editors scrub timelines with the dial, switch tools with buttons, feel haptic feedback on actions. The workflow structure is identical: select a mode, trigger an action, review output sequentially, accept or reject. Conductor applies that same proven pattern to the 40 million developers using AI coding tools today — a market where zero hardware exists for this workflow.

What it does

Conductor would map every piece of MX Creative Console hardware to a specific part of the AI coding workflow — designed to work with any AI tool, not locked to a single provider.

Keypad (9 LCD buttons) — Each button is a skill — a pre-configured AI command with a curated prompt behind it. Every experienced AI coder has prompts they've refined over dozens of uses: the refactor prompt tuned to their architecture, the test generator that matches their patterns, the documentation prompt styled to their team's conventions. Today, these live scattered across pinned chats, config files, or just muscle memory. Conductor gives them a physical home.

Out of the box, Conductor ships with sensible defaults — Implement, Refactor, Fix, Test, Type, Document, Review, Optimize, Explain. But each button is fully reconfigurable. A React developer maps one button to "Convert this class component to a functional component with proper hook extraction." A backend engineer maps one to their migration generator. The prompt is yours, the button just fires it.

A developer selects code in their editor and presses a button — no typing required. The command routes to whatever AI tool is active. The LCD display on each button shows real-time status: an icon when idle, an amber pulse while AI is generating, a green dot when changes are ready for review, a red flash if something failed. At a glance, you'd know exactly where every command stands — regardless of which tool produced the output.

Dial — Diff Scrubber + AI Operation Timeline — The centerpiece of the concept. After AI generates changes across multiple files, the developer rotates the dial to scrub through them one by one — the same muscle memory as scrubbing a video timeline. The LCD ring displays which file you're reviewing ("3/5 — auth.service.ts"). Press the dial to accept the current diff. Rotate to the next. Four files reviewed in eight seconds instead of eight clicks.

A long-press switches the dial to timeline mode — a navigable history of every AI operation. Every prompt you fired, every change the AI made, captured as a checkpoint you can revert to. Rotation scrubs through the timeline. The LCD shows "Checkpoint 3/7 — Refactor auth." Press to restore. One physical gesture to undo what the AI broke — regardless of which tool made the changes. The checkpoint system is built on git primitives (git stash create captures working tree state with zero side effects), so it uses infrastructure developers already trust. All data stays local on disk.

Roller — Navigates between diff hunks within a single file. When AI changes 200 lines across multiple sections, the roller lets you jump between each change without scrolling manually.

Actions Ring (MX Master 4) — A radial overlay with 8 context-sensitive commands at the cursor: Edit, Fix, Explain, Accept, Reject, Checkpoint, Rewind, New Chat. A thumb gesture opens the ring, a tap fires the action. No chat box. No context switch.

Haptic Feedback (MX Master 4) — A soft vibration pulse when AI finishes generating. A double-tap when all diffs are accepted. A sharp tap when the AI needs a permission decision. You feel the workflow instead of watching spinners. Eyes stay on code.

How we plan to build it

Conductor's architecture consists of two components connected by a local WebSocket:

A Logi Actions SDK plugin (C# / .NET 8) — scaffolded with the LogiPluginTool CLI, using PluginDynamicCommand for the keypad buttons, PluginDynamicAdjustment for the dial, GetCommandImage for dynamic LCD rendering, and the Haptics API for MX Master 4 feedback. Every feature maps to a documented SDK capability — we confirmed this against the full Actions SDK documentation.

A VS Code extension (TypeScript) — a companion that bridges hardware events to the editor. The extension has two layers:

  • A universal layer that works with any AI tool out of the box. For tools that accept terminal input (Aider, Copilot CLI, most tools), it injects commands via VS Code's sendSequence API. For tools with custom terminal UIs like Claude Code (whose Ink-based interface doesn't accept programmatic submission — a known limitation we found during research), it routes through headless mode (claude -p --resume). The extension auto-detects which path to use. Diff navigation uses VS Code's built-in nextChange/previousChange commands. AI completion is detected via a file-change settle heuristic.

  • An enrichment layer that adds richer status for tools that expose APIs. Claude Code's hooks system can relay lifecycle events (PostToolUse, PermissionRequest, SubagentSpawn) to the extension via lightweight relay scripts — the same pattern GitButler uses in production. GitHub Copilot's extension commands enable suggestion cycling. These are optional — Conductor works without them.

The checkpoint timeline is built on git stash create (captures state without side effects) and git checkout (restores state). Before each AI command, the extension snapshots the working tree. After completion, it records the changed files. The dial scrubs through this index. All local, all git-native.

We've validated every integration point: the Logi SDK features, the VS Code APIs, the Claude Code limitation and its workaround, the git checkpoint mechanics, and the WebSocket relay pattern. The architecture is designed so adding JetBrains support means building a new IDE extension that speaks the same protocol — the hardware plugin stays untouched.

Why this matters — for Logitech

A new market. The MX Creative Console is marketed to video editors, musicians, and designers. Conductor opens it to 40 million developers — an audience that currently has zero reason to buy one. The developer tools use case would push every SDK feature (dynamic LCD rendering, multistate actions, haptic patterns, Actions Ring) in ways that existing creative plugins don't.

A distribution channel. Conductor submits to both the Logitech Marketplace and the VS Code Marketplace (34,000+ extensions, millions of installs). This creates an organic discovery path: a developer finds the VS Code extension, realizes it works with MX hardware, and buys the console. No other Logitech plugin has this dual-marketplace strategy.

A clear marketing narrative. "The same console that editors use to scrub timelines, developers now use to scrub AI diffs." One sentence. One visual. Logitech's marketing team could run this as a campaign tomorrow. The structural parallel between creative and developer workflows is the kind of insight that makes a 30-second ad write itself.

Zero competition. We searched the entire Logitech Marketplace, VS Code Marketplace, and Elgato Stream Deck ecosystem. Nobody has built physical controls for the AI coding workflow. Logitech's own "MX for Coders" page has no actual coding plugins. First mover in an empty category.

Challenges we ran into

This project is in the ideation and concept phase — we don't have the physical hardware during the application round. But the research process surfaced real challenges that made the architecture stronger.

Our initial concept targeted Cursor, the most popular AI editor. Research revealed that Cursor's AI features are proprietary and unexposed through any Extension API — a dead end we caught before building. This pushed us to the tool-agnostic architecture: terminal injection for standard tools, headless mode for Ink-based UIs, enrichment for tools with APIs.

We discovered that VS Code's sendSequence doesn't work with Claude Code's Ink-based terminal UI (GitHub issue #15553). Rather than ignoring it, we designed the dual-path system — and this became a differentiator, because it means Conductor handles edge cases that other concepts in this space haven't even identified.

We studied Claude Code's hooks system and learned that hooks are user-configured shell scripts, not a subscription API. This shaped the enrichment layer: Conductor ships relay scripts, the user adds them once, and richer status flows. GitButler validates this exact pattern in production.

Every limitation we found led to a better design. The dual-path command system, git-based checkpoints, and universal-plus-enrichment architecture all exist because we hit a wall and solved it rather than pretending it wasn't there.

Accomplishments that we're proud of

We identified that the AI coding workflow and the creative workflow are structurally identical — and that nobody has acted on this insight. Select a mode (button press), trigger an action (send prompt), review output sequentially (dial rotation), accept or reject (dial press). This isn't a marketing claim. It's a direct mapping of the interaction pattern Logitech already solved for video editors, applied to a 40-million-developer market with zero hardware competition.

We validated the full technical architecture against real documentation and real edge cases — not just the happy path. Every proposed feature maps to a documented capability, every limitation is identified and solved, and we can point to production examples (GitButler, HapticWebPlugin) that validate our architecture patterns.

What we learned

Validate feasibility at every layer before building. Discovering Cursor's locked API, Claude Code's terminal submission limitation, and the difference between hooks-as-event-stream versus hooks-as-configured-scripts shaped every architectural decision. Each wall we hit produced a better design.

Design for the ecosystem, not a single tool. The AI coding landscape is fragmenting fast — developers already use 2-3 tools simultaneously. A hardware layer that works with everything and gets richer with tools that cooperate is more durable than one locked to any single provider.

The Logi Actions SDK is significantly more capable than its current Marketplace utilization suggests. Dynamic LCD rendering, multistate actions, haptic waveform patterns, Actions Ring integration — capabilities that almost no existing plugin fully exploits. The developer tools use case is where these features finally get pushed to their potential.

What's next for Conductor

Phase 1 — Build the Logi Actions SDK plugin with skill-mapped keypad buttons, dial-based diff navigation, and haptic feedback.

Phase 2 — Build and publish the VS Code extension with the dual-path command system — working out of the box with Claude Code, Copilot CLI, Aider, Cursor, and any other AI tool.

Phase 3 — Implement the git-based checkpoint timeline with dial navigation and restore-on-press.

Phase 4 — Ship Claude Code and Copilot enrichment adapters for granular LCD status.

Phase 5 — Add JetBrains support via their Plugin SDK.

Phase 6 — Submit to both the Logitech Marketplace and VS Code Marketplace — making the MX Creative Console the first hardware product with a dedicated developer tools plugin.

Built With

Logi Actions SDK, C#, .NET 8, TypeScript, VS Code Extension API, WebSocket, React, Vite, Tailwind CSS, Monaco Editor, GSAP, Remotion

Built With

Share this project:

Updates