Malleable Software: Why Ink & Switch Says AI Code Generation Alone Won't Return Control to Users

Ink & Switch's 2025 essay on malleable software argues that giving users real control over their tools requires more than settings menus, plugins, modding communities, or open-source code — and notably, more than today's AI code generation tools. It's a pointed critique aimed at a moment when Cursor, Copilot, and Claude Code have made 'anyone can code' feel plausible again. The essay's real target is the architecture of software itself, not the skill gap of the people using it.

The Old Promise of End-User Programming

Before app stores and subscription SaaS became the default, tools like HyperCard, Excel macros, and Unix pipes let non-programmers reshape software to fit their own workflows with relatively little friction. That capability didn't disappear because users stopped wanting it — it eroded as software consolidated into closed, centrally-controlled platforms. Ink & Switch, a research lab known for its work on local-first software, frames malleable software as an attempt to recover that lost flexibility for a modern context.

Where Settings, Plugins, Modding, and Open Source Fall Short

The essay walks through the usual answers to 'how do users customize software' and finds each one incomplete. Settings only expose the options a developer already anticipated. Plugin systems require understanding a specific app's extension API, which is itself a form of programming. Modding works well in gaming but rarely extends to productivity software. Open source makes code visible, but 'visible' isn't the same as 'safely modifiable' — reading a codebase and confidently changing it are very different skill levels. Each mechanism gives users a narrow lane of control, not the general-purpose adaptability the essay is arguing for.

Why AI Code Generation Isn't the Fix Either

This is the sharper argument in the piece: AI coding assistants are good at generating new code from scratch, but modifying an existing, running application safely is a structurally different problem. Without insight into how a tool's internal data and logic are organized, an AI model editing blind can introduce breakage that's hard to predict or contain. The essay's implication is that the bottleneck isn't AI capability catching up — it's whether the underlying software is built with open, composable structures that make modification tractable in the first place, for AI or humans alike.

How This Connects to the Broader AI-Agent Moment

We've previously covered Open Executive (https://omnitop-tech.blogspot.com/2026/08/open-executive-developers-build-open.html), an open-source project that used Claude Sonnet-based agents to replace executive-level decision-making functions. Both projects sit inside the same 2025 wave of asking 'what should users/organizations be able to reshape with AI now available' — but the comparison is instructive. Open Executive used AI agents to build new capability from the outside in. Malleable software argues that without changing how software itself is architected, AI agents will keep running into the same wall Open Executive's builders would eventually hit: closed systems that resist safe, granular modification regardless of how capable the AI is.

Why It Matters Beyond Developer Circles

The stakes here aren't abstract. Most consumer and enterprise software — from CRM platforms to note-taking apps to internal business tools — is built on architectures that assume users won't touch the internals. If AI coding tools mature without a parallel shift toward more open, composable software design, the practical ceiling on 'AI-assisted customization' will stay low no matter how good the models get. Companies that expose stable APIs, plugin surfaces, or local-first data formats stand to benefit disproportionately as AI-assisted customization becomes a real user expectation rather than a developer niche.

Takeaway

The essay reframes a familiar debate: the constraint on user-driven software customization was never just a skills gap that AI can close by writing code faster. It's a design and access problem baked into how most software is built today — and that problem persists whether the person trying to modify the tool is human or an AI agent.

Reference: https://www.inkandswitch.com/essay/malleable-software/