Malleable Software

Software that users can reshape from within — including cheap, disposable, self-made tools — revived as AI collapses the cost of modification.

Also known as: malleable software, Internal Reprogrammability, reimagining, disposable software, Sketches, sketches

How authors use it

Oldest first (extraction date when no publication date is known).

Documents (8)

• The case for making your own apps Casey Newton · 2026-07-22 source ↗ Reader 🖥️
  As AI collapses the cost of building software toward zero, a large and growing share of the software people use — within a few years, plausibly a third to half of it — will be hyper-personalized, disposable software they (or their friends and colleagues) make themselves, which will hollow out commercial SaaS products whose value was mainly a mediocre one-size-fits-all UI while sparing those that hold irreplaceable data or can operate headlessly.
• Software Design in the Agentic Age: Place Your Bets Mathias Verraes · 2026-07-07 source ↗ Reader 🖥️
  In the agentic age, code-level quality becomes automatable but high-level software design and rigorous (ideally executable) specifications remain decisive human-led work, so under deep uncertainty about AI's payoffs and externalities teams should bet on design rigour, executable specifications, and the ability to revert from agent generation back to human engineering.
• Should You Still Become a Software Engineer in 2026? GitHub VP Jean Lee (interviewer); Scott Hanselman (guest, VP & Member of Technical Staff, Microsoft/GitHub) · 2026-06-25 source ↗ Reader 🖥️
  AI coding agents are the latest in a recurring cycle of developer 'power tools' that change the tools but not the craft or its human accountability, so the real risk of the AI era is not that engineers become obsolete but that the profession fails to deliberately re-engineer its junior-to-senior training pipeline (via something like nursing's preceptor model) before AI hollows out the tasks juniors traditionally learned on.
• Bliki: Vibe Coding Martin Fowler · 2026-05-21 source ↗ Reader 🖥️
  Vibe coding — building software by prompting an LLM without ever looking at the generated code — is a distinct practice from agentic programming, useful only for disposable software, because forgetting the code exists produces serious risks in security, maintainability, and correctness.
• Why cultivating agency matters more than cultivating skills in the AI era | Max Schoening (Head of Product, Notion) Lenny Rachitsky, Max Schoening · 2026-05-09 Reader 🖥️
  In the AI era, the differentiating factor for product builders is not skill acquisition but agency — the willingness to treat the world as malleable and to make things — and the products that endure are those built around a tiny, exceptionally good core rather than an accumulation of features.
• Applying Best Simple System for Now for Software Design Ben Linders · 2026-05-09 source ↗ Reader 🖥️
  The trade-off between technical debt and missed deadlines is a false dichotomy; by building the simplest system that meets only current requirements to a high standard (Best Simple System for Now), teams can ship continuously while keeping future change cheap — because simplicity, not speculative flexibility, is the real source of adaptability.
• Fragments: May 5 Martin Fowler · 2026-05-05 source ↗ Reader 🖥️
  The current moment in AI-assisted software development is defined by a tension between the power of cloud-hosted AI genies and the risks they carry — to code quality, to truth, to budgets, and to autonomy — and the pieces Fowler curates collectively ask whether the escape route runs through disciplined engineering practice, local-first computing, or some combination of both.
• Radar Trends to Watch: May 2026 Mike Loukides and Claude · 2026-04-20 Reader 🖥️
  The AI industry is rapidly moving from experimental models to operational infrastructure — agents, orchestration layers, and security tooling — and the central tension is between open deployment and controlled access, a tension most visible in the divergent approaches to frontier security capabilities taken by Anthropic (restrict) and OpenAI (release).

Propositions touching this concept (3)

By publication month, oldest first (extraction month when no publication date is known).

2026-02

• explicitAI-enabled non-professionals writing their own disposable software (hobbyists, an accountant building her own automation) expands who writes software without threatening the professional discipline, paralleling the hobbyist wave that accompanied the rise of personal computers in the late 1970s/80s.
  The third golden age of software engineering – thanks to AI, with Grady Booch · p12

2026-05

• implicitThe category 'disposable software' is stable and identifiable in advance.
  Bliki: Vibe Coding · p10
• explicitAgentic programming is recovering the Great Lost Joy of molding one's own development environment — the Internal Reprogrammability that was central to Smalltalk/Lisp but lost in the IDE era.
  Fragments: May 5 · p2

Tensions

Open gaps (18)

• incompleteAgency is presented as the key differentiator but its uneven distribution is noted without exploring why. Structural barriers to agency (economic precarity, organizational culture, psychological safety, access to tools) are absent from the analysis. The advice to 'just make things' assumes access and psychological conditions that are themselves unevenly distributed.
  Why cultivating agency matters more than cultivating skills in the AI era | Max Schoening (Head of Product, Notion) — read next: Amartya Sen's 'Development as Freedom' on capability theory; research on psychological safety (Amy Edmondson) as a precondition for agency in organizations
• incompleteThe intelligence-saturation thesis (retina display analogy) is provocative but untested. Whether knowledge work has a clean saturation point or a long tail of edge cases requiring frontier intelligence is not examined. The analogy breaks if cognitive tasks are heterogeneous in their intelligence requirements.
  Why cultivating agency matters more than cultivating skills in the AI era | Max Schoening (Head of Product, Notion) — read next: Research on scaling laws and emergent capabilities in LLMs; Dario Amodei's 'Machines of Loving Grace' essay on where intelligence bottlenecks actually bind
• incompleteThe conversation repeatedly invokes 'quality' and 'craft' as things the industry is losing but offers no mechanism for measuring or incentivizing quality in an era where shipping speed is the dominant metric. The 'obviously good' standard is acknowledged to be subjective ('you know it when you see it').
  Why cultivating agency matters more than cultivating skills in the AI era | Max Schoening (Head of Product, Notion) — read next: John Ousterhout's 'A Philosophy of Software Design' on complexity as the enemy of quality; the Toyota Production System literature on building quality into the process rather than inspecting it afterward
• incompleteNo discussion of how BSSN handles genuinely uncertain or conflicting current requirements. The framework assumes 'current requirements' are knowable and stable, but in many contexts they are ambiguous or in flux.
  Applying Best Simple System for Now for Software Design
• incompleteNo treatment of team or organizational dynamics. BSSN is presented as an individual design discipline. How does it interact with architectural governance, platform teams, or mandated standards that may require speculative infrastructure?
  Applying Best Simple System for Now for Software Design
• illogicalMinor tension: the 'Best' characteristic requires telemetry, automated tests, API docs, and automated deployment paths. These are themselves forward-looking investments that go beyond 'current requirements'. The boundary between 'necessary quality infrastructure' and 'speculative code' is not clearly drawn.
  Applying Best Simple System for Now for Software Design
• incompleteFowler offers no mechanism for detecting when 'disposable' software is silently graduating into consequential software. The disposable/consequential boundary is treated as legible to the author, but in practice it is one of the most common failure modes in software organisations — internal scripts becoming critical infrastructure.
  Bliki: Vibe Coding — read next: Cutler on institutional overload and shadow systems; classic discussions of 'tactical' vs 'strategic' programming (Ousterhout, Philosophy of Software Design); literature on shadow IT and end-user computing.
• incompleteNo engagement with the cultural/professional question of whether vibe coding deserves the name 'coding' at all, or whether legitimising it as a coding practice (rather than, say, 'spec-driven prototyping') invites exactly the diffusion problem Fowler is trying to push back against.
  Bliki: Vibe Coding — read next: Naur on programming as theory building; the broader 'what is programming' debate that has resurfaced post-LLM.
• unstated assumptionFowler's curation implicitly assumes that the discipline-vs-tarpit tension is the defining axis of AI-assisted development, but economic and organizational dimensions (team structure, hiring, skill deskilling) are largely absent from the fragments selected.
  Fragments: May 5 — read next: Cross-reference with pieces on how AI changes team composition and organizational design (e.g., the 'kill your org chart' literature).
• implicit premiseThe local-model argument rests on a single practitioner's 'good enough' assessment (van den Ende). There is no quantitative comparison of local vs. cloud model performance on real engineering tasks, leaving the threshold claim unsubstantiated.
  Fragments: May 5 — read next: Look for benchmarks comparing local open-weight models (e.g., Llama 3, Mistral) against cloud models on SWE-bench or similar agentic coding evaluations.
• selection biasThe fragments are curated from Fowler's professional network (ThoughtWorks colleagues, Beck, Jessitron, RedMonk) — a community that values craft and internal quality. The 'move fast and let AI clean up later' perspective is represented only as a foil, not through its strongest advocates.
  Fragments: May 5 — read next: Seek out arguments from the 'galaxy brain' camp — practitioners or companies that have successfully scaled with AI-generated code despite low internal quality.
• incompleteThe article presents the three-layer agentic stack (orchestration, execution, review) as an emerging standard but provides no analysis of whether this architecture is actually sound or just the first thing that crystallized. There is no discussion of failure modes, debugging, or accountability within this architecture.
  Radar Trends to Watch: May 2026 — read next: Bryan Cantrill's laziness essay; 'Hidden Technical Debt of Agentic Engineering'; distributed systems architecture literature
• incompleteThe tension between 'reimagining' (rebuilding software from scratch with AI) and 'laziness' (the virtue of designing for future maintainability) is present in the article but never connected. If AI makes building cheap but maintaining thoughtful, these two trends are on a collision course.
  Radar Trends to Watch: May 2026 — read next: Cantrill's full essay on laziness; the original 'Hidden Technical Debt in Machine Learning Systems' paper
• uninformedThe article does not address the labor market implications of AI becoming operational at the team level. If agents replace team-level workflows, the impact on employment is qualitatively different from individual productivity gains.
  Radar Trends to Watch: May 2026 — read next: Daron Acemoglu's work on AI and labor; the Stanford AI Index's labor market sections
• incompleteThe co-authorship attribution ('Mike Loukides and Claude') is noted without comment. The article does not discuss what it means for a trends roundup to be co-authored by an AI model — raising questions about editorial judgment, selection bias, and the epistemic status of the analysis.
  Radar Trends to Watch: May 2026 — read next: Discussions of AI co-authorship norms; editorial standards for AI-assisted journalism
• incompleteThe essay surveys the debate over disposable, regenerable code but leaves it unresolved by admission: it does not settle when the token and verification cost of regenerating code from specifications beats patching, nor whether frequent regeneration makes the system less deterministic.
  Software Design in the Agentic Age: Place Your Bets — read next: Seek empirical data or benchmarks comparing regenerate-from-spec versus patch-in-place on cost, determinism, and verification of functional and non-functional requirements.
• incompleteNo engagement with the maintenance burden of personal software: who fixes a self-made app when the underlying AI model changes behavior, an integrated API changes, or a bug surfaces months later — especially for the large population of non-technical creators Glaze is explicitly targeting, who by definition cannot debug it themselves.
  The case for making your own apps — read next: Newton's own earlier hands-on Glaze review (extract-platformer-vibe-coding-escaped-terminal) and Fowler's vibe-coding bliki entry, both of which raise exactly this accountability/maintenance gap for AI-generated software more generally.
• incompleteSecurity and data handling of hyper-personalized apps built by non-programmers is never discussed, despite Mann's own admission that Glaze apps connect to internal knowledge bases, support data, and third-party APIs — precisely the combination of private-data access plus external connectivity the corpus's 'lethal trifecta' framework flags as risky, especially when built by people with no security training.
  The case for making your own apps — read next: extract-fowler-bliki-vibe-coding#g4, which raises the identical gap (non-programmers being least equipped to recognize security trifectas) for vibe coding generally.