What happens when your keyboard gets a co-pilot and a physical keypad joins the team?

From issuing commands to making intent executable

For most of Martin Woodward's career, building software started with the same setup: keyboard, mouse, editor, terminal, browser, and an impressive number of tabs he was definitely going to look at later. The tools changed, but the relationship did not. Like most developers, he learned commands, memorized shortcuts, and adapted his thinking to the machine.

AI is changing that relationship. Not because a developer can prompt their way to workable code. It is because the system behind it can understand a repository, choose the right model, plan work, use tools, edit files, run commands, inspect failures, and keep going within boundaries the developer controls.

The system has made it possible for a developer to describe an outcome. GitHub Copilot gathers repository context, inspects symbols, edits files, runs tests, and revises the implementation.

In the IDE, agent mode keeps that loop interactive. GitHub Copilot coding agent can take an issue into an isolated GitHub Actions-powered environment and return a pull request for review. This is not just faster coding. It is the shift from issuing commands to making intent executable. The developer still owns the outcome, but the work looks subtly different.

AI-assisted development compresses that chain of events. Developers spend less time navigating tools and more time setting direction, supplying context, defining constraints, and reviewing evidence. The development workflow now is about understanding the structure of codebases, the customer, and what a good solution should feel like. This makes developers' jobs even more important, and their time more valuable. It makes judgment more valuable. It makes taste more valuable.

An agent can generate three implementations before you finish your tea. Someone still has to decide whether the abstraction belongs, the migration is safe, the tests prove anything useful, and the result solves the problem. That is the most important change in the craft: the developer remains accountable for the outcome, even as more mechanics are delegated.

Three layers that keep control in human hands

The VP of Developer Relations sees three layers. Modality captures intent. The harness plans and acts. The control plane lets developers inspect, redirect, and approve. The best products connect all three without surrendering control. Together, they let developers move across text, voice, and physical controls without losing context.

Embedding AI into the workflow, not beside it, is the target. It is more of an ambient intelligence. 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 need explicit context underneath.

GUIs made software visual. Mouse made navigation easier. The web made it connected. Mobile made touch natural. Agents add intent and action. The interface now includes ambient control. The interface moves into the background.

Why physical controls are interesting again

The maker community has been experimenting with ambient control devices for 18 months. From inexpensive hackable picture frames to ESP32 devices with screens attached. Agentic coding is past just a keyboard and a terminal into alternative interfaces.

Getting this kind of technology into everyone's hands is something Woodward is very passionate about. Over the past 18 months GitHub has been working with Logitech on their MX Keypad and how it can help this new way of working.

The Logitech MX Keypad turns familiar developer actions into programmable inputs to accelerate workflows that are ambient and contextual to the work developers are doing. In GitHub Copilot app, a key can submit a parameterized prompt or open a Copilot session. It can also invoke an IDE command or trigger a multi-step sequence.

The hardware earns its place only when that shortcut removes enough friction to keep you in the code, but still gives you control. Physical controls work when an action repeats often enough that removing a few steps preserves concentration. Not every developer needs another device on the desk, and not every interruption deserves a key.

However, with this experience the developer decides which actions earn that shortcut and when the keyboard, command palette, or voice is better. Maintaining flow is the key, and a good interface gives some of that attention back.

The concrete experiment shipping today

Working with Logitech, the team integrated the GitHub Copilot app directly into the experience. Developers can run agentic workflows in control, map a repeated prompt, start or resume a session, and decide through real use whether a physical control helps them stay in flow.

This is still early, so the important 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 creating conflicting pull requests?

Products such as MX Keypad let GitHub explore one practical part of that system: how developers invoke, steer, and resume agentic work without losing focus.

Pairing MX Keypad with GitHub Copilot Pro+ gives developers a concrete experiment: choose one repeated interruption, map it to a control, and see whether it preserves focus. If you want to try it, you can do so here and get three months of GitHub Copilot Pro+.

For decades, developers learned to speak computer: syntax, commands, APIs, shortcuts, and the occasional incantation copied from a seven-year-old issue comment. Now computers are getting better at meeting us halfway. The best interface will not have the most panels or AI buttons. It will understand enough context, preserve meaningful control, and get out of the way so we can build software that matters. The goal is not to remove developers from the work. It is to remove friction around the work.