# Execution is Not an Interface _Why AI coding still needs maps when execution becomes programmable._ **TL;DR —** AI can increasingly execute software work. That does not remove the human interface problem; it makes system legibility, provenance and navigation more important. > **Archive update · September 2026** > > The article this responds to is real: Gwen Davis published “The era of ‘AI as text’ is over. Execution is the new interface.” on the GitHub Blog on 10 March 2026. The argument below still disagrees with the phrase, not with the underlying move toward programmable agentic execution. Something important has shifted in software development. AI systems can increasingly plan, call tools, change files, run tests and execute work instead of only returning text. But the phrase *execution is the new interface* still bothers me. > Execution is not an interface. Execution is what happens behind one. And confusing the two hides the design problem that becomes more important as machines assemble more of the system for us: **how do humans understand, navigate and control what was built?** **Argument map · From authorship to system legibility** Six states show software development moving from manual authorship through AI construction and execution toward coordinated system views that give developers a mental map. ```text 01 · Manual authorship The developer builds the system. Authorship creates a mental route through the code and its decisions. developer → code → execution 02 · Partial authorship AI shares construction. The developer stays responsible while direct familiarity with the implementation weakens. developer → AI construction → system 03 · Execution is not the map Logs, diffs, terminals and chat reveal activity. None of them alone provides a coherent mental model of the system. execution evidence → system legibility 04 · Structure as shared surface Graph-shaped artifacts expose relationships. Nodes, connections and contracts give humans and machines a representation above raw text. nodes + connections + contracts → map 05 · An emerging paradigm Command surfaces and generative UI now coexist. The next development interface has begun to appear, but it has not settled. terminal + agent CLI + MCP Apps / GenUI 06 · Coordinated projections One system, several useful views. Architecture, execution, provenance and narrative combine into a human mental map. multiple system views → developer understanding ``` ## The real shift: from writing systems to navigating systems For decades the dominant programming loop was easy to describe: ```text developer → code → execution ``` The developer did not literally hold every detail in their head, but authorship created cognitive scaffolding. You remembered the difficult function, the awkward boundary, the shortcut you promised yourself you would revisit. AI-assisted development weakens that relationship: ```text developer → AI → generated / modified system → execution ``` The developer remains responsible, while authorship becomes partial. The job does not disappear. It changes shape. > The centre of gravity moves from writing every part of the system toward navigating, reviewing and steering a system whose construction is increasingly shared with machines. ## The visibility problem When large portions of a system arrive fully formed, the missing thing is often not code. It is the **story and structure** that make the code inhabitable. **Structure** What depends on what? **Intent** Why does this module exist? **Provenance** Who or what changed it, and why? **Risk** Where are the fragile boundaries? This is why the familiar file tree and editor are necessary but insufficient. They show the implementation. They do not automatically show the system as a mental model. The analogy I still like is writing a long paper. When you write it yourself, you remember the route through the argument. If a model produces most of it, you need an additional map to understand how the argument hangs together. ## Execution solves infrastructure, not legibility Agentic development has made genuine infrastructure progress. Systems can plan tasks, invoke APIs, manipulate repositories, run tests and recover from some failures. That matters. But it does not answer the interface question. > **The interface question** > > How can a human inspect the system at the level at which they are now expected to take responsibility for it? Logs are useful. Diffs are useful. Terminals are useful. Chat is useful. None of them, alone, is the map. ## The early signal is structured systems Tools such as n8n are interesting here because the artifact is already both executable and structurally legible: a workflow is represented as nodes, parameters and connections. I would now state the old claim more carefully. It is not that n8n “works with AI because it exposes structure.” That is too causal. The useful observation is simpler: **graph-structured artifacts give both humans and machines a representation above raw text.** > Structures are understood through maps. ## The terminal renaissance — and what changed since March The return of command-driven agent tools made sense. Terminals are fast, composable and easy to instrument. When AI behaves unpredictably, a terminal gives developers a place to inspect, retry and intervene. But I would change one sentence from the original article. In March I wrote that the next interface paradigm “has not been invented yet.” By September that is too absolute. [MCP Apps](https://modelcontextprotocol.io/extensions/apps/overview) are now an official extension for interactive UI inside MCP hosts, and generative-UI work is explicitly exploring task-shaped, dynamically rendered surfaces. The paradigm has not failed to appear. **It has not settled.** ## What an AI-native development interface might expose Instead of treating the source tree as the only view, development environments can project several coordinated views over the same system: **Architecture** Modules, services, contracts and dependencies. **Execution** Calls, tools, traces and state transitions. **Provenance** Human and model changes, rationale, diffs and evidence. **Narrative** How the system evolved and where decisions accumulated. These do not replace code. They make machine-assisted code navigable. > AI may generate the code. **But developers still need the map.** ## Sources - [Gwen Davis, GitHub Blog — “Execution is the new interface” (10 March 2026)](https://github.blog/ai-and-ml/github-copilot/the-era-of-ai-as-text-is-over-execution-is-the-new-interface/) - [Model Context Protocol — MCP Apps overview](https://modelcontextprotocol.io/extensions/apps/overview)