*Disclaimer: the research behind this page was AI-generated: gathered and written by Claude using [swamp](https://github.com/swamp-club/swamp) workflows and [Exa](https://exa.ai) search. Check the linked sources before relying on a summary.* Developers spend more than half their time working out how a system behaves before they can decide what to change ([Girba & Wardley, Rewilding ch. 2](https://medium.com/feenk/rewilding-software-engineering-083b86c81c43)). The mainstream IDE still puts most of its effort into *writing* code: a text editor over files, plus a language server and a debugger. Writing code is also the part that coding LLMs now push toward commodity. That leaves understanding the system as the open problem, and two industries are trying to solve it from opposite directions. ## The map ```mermaid wardley-beta title Developer environments: understanding vs. writing code size [1100, 720] anchor Developer [0.97, 0.55] component Changing a system safely [0.89, 0.50] component Understanding the system [0.80, 0.25] component Writing code [0.78, 0.82] component Agent orchestration workspace [0.70, 0.30] component Generated views [0.64, 0.10] component Moldable views [0.60, 0.24] component Spatial code canvas [0.47, 0.14] component Notebooks [0.52, 0.66] component Text editor [0.60, 0.95] label [-95, 4] (inertia) component Language server [0.50, 0.88] label [-125, 4] component Debugger [0.42, 0.74] component Generic object inspector [0.34, 0.82] label [-195, 4] component Live object environment [0.34, 0.28] component Coding LLM [0.28, 0.62] component Source as text files [0.20, 0.94] label [-165, 4] (inertia) component Compute [0.06, 0.96] label [-70, 4] Developer -> Changing a system safely Changing a system safely -> Understanding the system Changing a system safely -> Writing code Understanding the system -> Moldable views Understanding the system -> Generated views Understanding the system -> Spatial code canvas Understanding the system -> Debugger Understanding the system -> Notebooks Writing code -> Text editor Writing code -> Agent orchestration workspace Agent orchestration workspace -> Coding LLM Generated views -> Coding LLM Moldable views -> Live object environment Moldable views -> Generic object inspector Spatial code canvas -> Source as text files Text editor -> Language server Text editor -> Source as text files Language server -> Source as text files Debugger -> Generic object inspector Generic object inspector -> Compute Live object environment -> Compute Coding LLM -> Compute evolve Writing code 0.95 evolve Moldable views 0.42 evolve Agent orchestration workspace 0.55 evolve Coding LLM 0.85 note "Glamorous Toolkit, Clerk, Portal" [0.565, 0.25] note "Roer" [0.70, 0.03] note "Code Bubbles, Debugger Canvas" [0.425, 0.03] note "Intent, Cursor 2.0, Agor" [0.665, 0.33] ``` How to read it: - **Writing code** is moving to commodity. Agents write a growing share of it. - **Understanding the system** sits in genesis and custom. It needs a different tool for each question. - **Moldable views** (Glamorous Toolkit, Clerk, Portal) make those tools cheap to write by hand, on top of a live object environment. - **Generated views** (JetBrains Roer) let an LLM draw the tool on demand. They are cheaper still, but there is no live object graph underneath. - **Agent orchestration workspaces** (Intent, Cursor 2.0, Agor) bet on the opposite: you write the spec, and you read less of the system. - **Source as text files** and **Text editor** carry inertia. Spatial canvases (Code Bubbles, Debugger Canvas) showed measurable gains and still did not replace them. ## Moldable development - Girba & Wardley, *Rewilding Software Engineering*: [ch. 1](https://medium.com/feenk/rewilding-software-engineering-900ca95ebc8c), [ch. 2](https://medium.com/feenk/rewilding-software-engineering-083b86c81c43), [ch. 4](https://medium.com/feenk/rewilding-software-engineering-a3601a066e50), [ch. 5](https://medium.com/feenk/chapter-5-different-folks-for-different-strokes-70d24a750dff), [ch. 6](https://medium.com/feenk/rewilding-software-engineering-ca3ad1e612d8) (2025–2026) - [Glamorous Toolkit](https://gtoolkit.com/) and [moldabledevelopment.com](https://moldabledevelopment.com/) - Chiș, Nierstrasz, Syrel & Gîrba, [The Moldable Inspector](https://scg.unibe.ch/archive/papers/Chis15a-MoldableInspector.pdf) (2015) - Nierstrasz & Gîrba, [Moldable Development Patterns](https://arxiv.org/abs/2409.18811) (2024) - Nierstrasz & Gîrba, [Making Systems Explainable](https://www.oscar.nierstrasz.org/files/publications/Nier22a-ExplainableSystems.pdf) (2022) - Girba, [Moldable Development with Glamorous Toolkit](https://www.youtube.com/watch?v=_ztGZpo9I9E) (talk, 2024) ## Moldable ideas outside Smalltalk - [Clerk](https://clerk.vision/): moldable live programming for Clojure - [Portal](https://github.com/djblue/portal): a Clojure inspector with custom viewers - [clog-moldable-inspector](https://codeberg.org/khinsen/clog-moldable-inspector) (Common Lisp, Konrad Hinsen) - [Beamtalk ADR 0095: Rich Navigable Inspector](https://www.beamtalk.dev/adr/0095-rich-navigable-inspector.html) (2026) - [roer-ui](https://claude-mods.com/roer-ui/): JetBrains Roer's generative UI in Claude Code (2026) ## Frameworks for comparing systems - Jakubovic, Edwards & Petricek, [Technical Dimensions of Programming Systems](https://arxiv.org/abs/2302.10003) (2023), and the [interactive catalogue](https://tomasp.net/techdims/) - [Technical Dimensions of Live Feedback in Programming Systems](https://joshuahhh.com/dims-of-feedback/dims-of-feedback.pdf) - Grigera, Costiou, Gardey & Ducasse, [It's Alive! What a Live Object Environment Changes in Software Engineering Practice](https://arxiv.org/abs/2603.02987) (IDE '26) ## Spatial code environments - Bragdon et al., [Code Bubbles](https://www.cs.ucf.edu/icerc/isuelab/publications/pubs/p293-bragdon.pdf) (2010) - DeLine et al., [Debugger Canvas: industrial experience with the Code Bubbles paradigm](http://www.andrewbragdon.com/papers/p1064-213-deline.pdf) - [Code Canvas vs. Code Bubbles vs. Debugger Canvas](https://learn.microsoft.com/en-us/archive/blogs/kaelr/code-canvas-vs-code-bubbles-vs-debugger-canvas) - Henley & Fleming, [The Patchworks Code Editor](https://austinhenley.com/pubs/Henley2014CHI_Patchworks.pdf) (CHI 2014) - [Effectiveness of Spatial Overviews for Navigating Software Projects](https://dl.acm.org/doi/full/10.1145/3831423.3831459) (Graphics Interface, 2026) - [Prior Art: rendering a whole codebase, spatially](https://ivanlugo.dev/prior-art/) ## Live programming - [LIVE workshop](https://liveprog.org/) and [all past programs](https://liveprog.org/all-programs.html) - [Renkon-Pad](https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.11) (2025) - [ShellVis: Sandboxed Live Programming for Shell Scripts](https://arxiv.org/abs/2609.11000) (2026) ## Malleable software and end-user programming - Ink & Switch, [Malleable software](https://www.inkandswitch.com/essay/malleable-software/) (2025) - Ink & Switch, [End-user Programming](https://www.inkandswitch.com/end-user-programming/) (2019) - Geoffrey Litt, [Malleable software in the age of LLMs](https://www.geoffreylitt.com/2023/03/25/llm-end-user-programming.html) (2023) ## The other bet: agentic workspaces - Amelia Wattenberger, [Intent: a workspace for agent orchestration](https://www.augmentcode.com/blog/intent-a-workspace-for-agent-orchestration) (2026) - [What Comes After the IDE, with Amelia Wattenberger](https://www.youtube.com/watch?v=79sDQ7JXVvQ) (2026) - [Agor: a spatial layer for agentic coding](https://agor.live/blog/announcement) (2025) - JetBrains, [Why We Still Need an IDE](https://blog.jetbrains.com/blog/2026/10/20/why-we-still-need-an-ide/) (2026)