The developer's relationship with the machine has been stable for decades: keyboard, mouse, editor, terminal, browser, and a growing stack of tabs. The tools changed, the interaction model did not. Developers memorized commands and shortcuts, and adapted their thinking to the system rather than the other way around.
What is shifting now is not the ability to prompt for workable code. It is that the system behind the prompt can understand a repository, select an appropriate model, plan work, call tools, edit files, run commands, inspect failures and continue — all inside boundaries the developer sets. A developer can describe an outcome, and GitHub Copilot can gather repository context, inspect symbols and dependencies, edit files, run tests and revise the implementation. Agent mode keeps that loop interactive in the IDE, while GitHub Copilot coding agent can take an issue into an isolated GitHub Actions-powered environment and return a pull request for review. The change is from issuing commands to making intent executable; accountability for the outcome stays with the developer.
As mechanics get delegated, the work compresses toward direction-setting: supplying context, defining constraints, and reviewing evidence. Judgment and taste carry more weight, not less. An agent can produce three implementations in the time it takes to finish a cup of tea, but a human still decides whether the abstraction belongs, whether the migration is safe, whether the tests prove anything, and whether the result solves the actual problem.
Ambient intelligence, not a sidecar
The emerging workflow embeds AI in the flow rather than beside it. That requires portable context: MCP connects agents to tools and services; repository instructions and skills encode conventions; hooks enforce policy and validate output. Simpler interfaces sit on top of explicit context.
Three layers define the shape:
- Modality captures intent.
- The harness plans and acts.
- The control plane lets developers inspect, redirect and approve.
The strongest products connect all three without giving up control, letting developers move across text, voice and physical controls without losing context.
Why hardware is interesting again
Physical controls are back in the conversation. The maker community has been experimenting with ambient devices, from inexpensive hackable picture frames to ESP32 boards with attached screens, and agentic coding has moved past the keyboard-and-terminal pairing. Over the past 18 months, GitHub has worked with Logitech on the MX Keypad and how it fits this way of working.
The MX Keypad maps familiar developer actions to programmable inputs so workflows can be ambient and contextual to the task at hand. Inside the GitHub Copilot app, a key can submit a parameterized prompt, open or resume a Copilot session, invoke an IDE command, or trigger a multi-step sequence. Hardware earns its desk space only when a shortcut removes enough friction to keep a developer in the code while preserving control.
The rule is repetition: a physical control pays off when an action recurs often enough that shaving a few steps protects concentration. Not every developer needs another device, and not every interruption deserves a key. The developer decides which actions earn a shortcut and when the keyboard, command palette or voice is the better choice. Maintaining flow is the point.
What still needs engineering
GitHub integrated the Copilot app directly into the MX Keypad experience: developers can run agentic workflows under control, map a repeated prompt, start or resume a session, and judge through real use whether a physical control helps them stay in flow.
Because this is early, the open questions are engineering questions. How much repository and organizational context should an agent retain? Which tool calls can run automatically? How should credentials, network access and secrets be scoped? What evidence should accompany a change? How do multiple agents coordinate without duplicating work or opening conflicting pull requests? The MX Keypad explores one practical piece of that system: how developers invoke, steer and resume agentic work without losing focus.
GUIs made software visual, the mouse made navigation easier, the web made it connected, and mobile made touch natural. Agents add intent and action; ambient control becomes part of the interface. The goal is not to remove developers from the work but to remove friction around it. Pairing an MX Keypad with GitHub Copilot Pro+ is a concrete experiment: pick one repeated interruption, map it to a control, and see whether it preserves focus.
