Geoffrey Litt researches and builds tools for more malleable software, local-first data and user-shaped computing environments. His essays and collaborative prototypes ask how people can adapt their digital tools instead of only accepting fixed applications. — Ink & Switch — Malleable Software.

Part 1: Malleable Software and User Agency
- Malleability as an evolving environment: Malleable software is not merely disposable code: Litt describes living in a computing environment and reshaping it over time as needs change. — Dialectic — Software You Can Shape.
- The furniture analogy: Litt compares adapting digital tools with the ordinary freedom to rearrange a physical space; the analogy illustrates the agency missing from many apps. — Ink & Switch — Malleable Software.
- The cost of static tools: In a direct interview, Litt describes the inability to alter one’s digital surroundings as a loss of agency. — Dialectic — Software You Can Shape.
- Tools rather than single-purpose apps: The coauthored essay contrasts a versatile knife with an avocado slicer to argue for composable tools that can serve needs beyond one prescribed workflow. — Ink & Switch — Malleable Software.
- Stability through adaptation: Litt distinguishes a tool that evolves with its users from one that is repeatedly replaced; this is a design aspiration, not a measured reliability claim. — Dialectic — Software You Can Shape.
- Control over digital surroundings: Litt and coauthors argue that locked-down applications require people to adapt their workflows to software, rather than allowing tools to adapt to them. — Ink & Switch — Malleable Software.
- Crafting rather than compulsory programming: Litt says the goal is more participation in shaping software, not simply teaching everyone conventional programming. — Dialectic — Software You Can Shape.
- Infrastructure for malleability: The Ink & Switch authors identify barriers from languages through operating systems and distribution; malleability therefore needs supporting infrastructure, not just a settings panel in one app. — Ink & Switch — Malleable Software.
- Physical environments as a model: The coauthored essay notes that people routinely adjust homes and workshops without asking a remote team for permission; it asks why software should be less adaptable. — Ink & Switch — Malleable Software.
- Editing tools at the point of use: Litt and coauthors envision gradual movement from using to creating software, with modification available near the work itself. — Ink & Switch — Malleable Software.
Part 2: Local-First Software and Data Sovereignty
- Local-first as a foundation: Litt and his Riffle coauthors describe local-first architecture as keeping app data available on the device while synchronizing when a network is available. — Riffle — Building Data-Centric Apps.
- Ownership through local data: The Riffle authors argue that locally available, freely editable data can give users more ownership and control than a server-only architecture. — Riffle — Building Data-Centric Apps.
- On-device access, with synchronization: Their proposed local-first pattern reads and writes locally, then synchronizes across clients when connected; the server is not necessarily absent. — Riffle — Building Data-Centric Apps.
- Collaborative rich text: Peritext, which Litt coauthored, uses CRDT techniques to merge concurrent rich-text edits without relying on one central editing session. — Ink & Switch — Peritext.
- Reducing app-state complexity: The Riffle prototype experiments with a reactive local database so UI queries update as state changes; the authors report promise alongside SQL and platform limitations. — Riffle — Building Data-Centric Apps.
- Semantic conflict still matters: The Peritext authors distinguish convergence of replicated text from human agreement about what a collaboratively edited document should mean. — Ink & Switch — Peritext.
- Durable personal data: In his Foam essay, Litt values keeping notes as local files in an open format so the material can remain useful beyond one particular application. — Foam: Software as Curation.
- Data control, not automatic secrecy: Litt’s local-first research emphasizes user control over locally stored data. It does not establish that every local-first application is inherently private or secure. — Riffle — Building Data-Centric Apps.
- Offline work as a design property: The Riffle authors argue that local storage lets an app remain usable when connectivity is poor or absent. — Riffle — Building Data-Centric Apps.
- Client choice and interoperability: Litt argues that users should be able to choose different clients for shared data, while acknowledging difficult format and collaboration tradeoffs. — Bring Your Own Client.
Part 3: AI-Assisted Programming and End-User Development
- The programmer’s critical work: Litt’s surgeon analogy puts the human on the central design or coding task while AI handles preparation and well-scoped supporting work. — Code Like a Surgeon.
- A fast but fallible junior collaborator: Litt compared GPT-4 with a junior developer who types quickly and knows libraries but can be careless; he presented this as his experience, not a general capability guarantee. — Malleable Software in the Age of LLMs.
- Asynchronous secondary work: Litt reports assigning tasks such as clear TypeScript fixes or documentation to AI agents in the background while reserving core design work for himself. — Code Like a Surgeon.
- A possible step change for end-user programming: Litt argues that LLMs might make custom software more accessible to nonprogrammers, while explicitly treating his forecast as speculative. — Malleable Software in the Age of LLMs.
- From intent to executable form: Litt identifies translating informal intent into formal code as a longstanding end-user programming bottleneck that LLMs may help loosen. — Malleable Software in the Age of LLMs.
- Make a UI for opaque output: After using AI to build a custom debugger, Litt suggests that even a JSON blob can merit a quick, task-specific interface when it improves understanding. — AI-Generated Tools Can Make Programming More Fun.
- Keep feedback loops visible: For his core prototyping work, Litt uses AI more cautiously and values fast feedback and visibility; he grants more autonomy to clearly bounded secondary tasks. — Code Like a Surgeon.
- AI as a creative prompt: Litt proposes using ChatGPT to ask questions and stimulate ideas rather than treating its answers as authoritative conclusions. — ChatGPT as Muse, Not Oracle.
- Small personal tools, as a possibility: Litt sees LLMs as a possible way to make one-off personal tools easier to build; his essay frames this as an emerging opportunity, not a universal prediction. — Malleable Software in the Age of LLMs.
- Make programming more enjoyable: Litt describes using AI to build a visual debugger while he wrote the main code himself; the custom view made the difficult programming task more engaging. — AI-Generated Tools Can Make Programming More Fun.
Part 4: Designing for Thinking and Dynamic Documents
- The bicycle-for-the-mind ideal: The Ink & Switch essay frames personal computing as a material people should be able to shape, not a sealed appliance; this is a design ideal, not an attributed verbatim quote. — Ink & Switch — Malleable Software.
- Documents that gain behavior: Potluck adds computational behavior to recipe notes, while Embark explores travel-plan outlines enriched with data, maps and formulas; both are research prototypes. — Ink & Switch — Embark.
- Software as curation: Litt argues that a useful personal tool can be assembled by selecting and combining existing components rather than writing every component from scratch. — Foam: Software as Curation.
- Use code for repeatable computation: The Potluck work enriches text with explicit computational behavior, such as recipe scaling, rather than asking a language model to regenerate each calculation. — Ink & Switch — Potluck.
- Low-latency reactive feedback: The Riffle authors argue that local queries can update the interface quickly enough for an interactive feedback loop; the performance target remains a research goal. — Riffle — Building Data-Centric Apps.
- Expose useful structure: Litt’s discussion of spreadsheets highlights how visible data and an always-available editing surface let users learn and alter a tool as they work. — Dialectic — Software You Can Shape.
- Why spreadsheets matter: The coauthored essay presents spreadsheets as a successful model of gradual progression from entering data to creating formulas and more complex tools. — Ink & Switch — Malleable Software.
- Environments shape thought: Litt argues that people develop tools by living and working in them, discovering changes they need through use rather than specifying everything upfront. — Dialectic — Software You Can Shape.
- Interactive documents: Potluck demonstrates documents whose contents can be gradually structured and computed upon—for example, scaling ingredients within a recipe note. — Ink & Switch — Potluck.
- Tools should extend human agency: Litt and coauthors frame malleable software as a way for people to shape their working environment themselves, rather than surrendering every design choice to a vendor. — Ink & Switch — Malleable Software.
Part 5: Research Philosophy and the Future of Software
- Prototype while using the tool: In interview, Litt describes beginning to live in an evolving software environment and refining it through use. — Dialectic — Software You Can Shape.
- Browser extensions as side projects: Litt recommends browser extensions as a practical way to alter existing web experiences and experiment with small personal tools. — For Your Next Side Project, Make a Browser Extension.
- Challenge the passive-user assumption: The Ink & Switch essay argues that many layers of computing assume users only consume software; its alternative is a gradual path toward co-creation. — Ink & Switch — Malleable Software.
- Sharing modifications: The coauthors describe the challenge of making personal modifications shareable and composable within groups, not merely customizing tools in isolation. — Ink & Switch — Malleable Software.
- Simplicity through composable parts: Their tools-not-apps argument favors recombining smaller tools around shared data over packing every use case into one monolithic application. — Ink & Switch — Malleable Software.
- Research through prototypes: Litt describes Ink & Switch’s work as using prototypes to explore and communicate alternative futures for software, with open limitations rather than finished products. — Dialectic — Software You Can Shape.
- Avoid the nightmare bicycle: Litt borrows Andrea diSessa’s nightmare-bicycle analogy to warn against interfaces that make a narrow trick easy while hiding a more general, learnable structure. — Avoid the Nightmare Bicycle.
- A gentler path to creation: Litt and coauthors propose a gradual path from using software to modifying it; they do not establish that professional programming and end-user activity are merely a historical accident. — Ink & Switch — Malleable Software.
- Malleability for groups: The coauthored essay extends customization beyond individuals to local groups that create and adapt tools together. — Ink & Switch — Malleable Software.
- Computing as a malleable medium: Litt and coauthors envision software that people can reshape near the moment a need arises; they present this as a research direction, not an achieved zero-friction state. — Ink & Switch — Malleable Software.
Learn more: