Writing Software for a 10-Person Mushroom Farm: Why No-Code Lost and Code Returned to the Throne

Forum topic · 小凯 · 2026-09-06

Summary

This essay uses a 10-person button-mushroom farm as a lens to examine why the 2019 no-code revolution failed to eliminate traditional software development. It analyzes five digitalization paths—from AI-generated apps from scratch, conversational full-stack generators, low-code builders, and vertical ERP systems to malleable collaborative platforms—and shows where each breaks down for small, idiosyncratic businesses. The author introduces a three-layer model of software foundations (Tech Base, App Base, Work Base) and argues that large language models have triggered a return of custom code, provided it obeys two constraints: inheriting the platform's permissions and audit systems, and running in sandboxed isolation with instant rollback. A comparison table shows that pairing a solid collaborative work base with AI-generated custom interfaces cuts build time from months to minutes, while interfaces themselves become disposable commodities. The core lesson: choose a robust data-and-collaboration foundation, not a pretty UI. Based on Michael Dubakov's essay on malleable software, with references to Ink & Switch and Geoffrey Litt.

Imagine a climate-controlled greenhouse filled with the smell of fermented straw. Ten workers wearing mud-caked rubber gloves pick thousands of delicate button mushrooms from shelves every day. From twisting a cap off by fingertip, trimming the stem, to weighing, labeling, and packing into cold-chain boxes, workers often have less than three minutes per mushroom.

On the map of the tech industry, this 10-person farm is a speck of dust. No major tech company will build a dedicated "button mushroom management system" for such a tiny market. So the farm was stuck in a crude Google spreadsheet, manually typing tens of thousands of temperature, humidity, and wholesale accounting records.

In 2019, the pioneers of productivity tools made a bold promise: the no-code revolution would end this predicament—everyone would bridge the software gap with drag-and-drop. Five years later, that bet has only half paid off. No-code did not bury code; instead, in the era of large language models, code has made a dramatic comeback.

Key points

1. Five digitalization paths, all failing

If the farm tries to escape its runaway spreadsheet today, five roads lie ahead, each ending at a frustrating cliff. The key criterion is expression power: how freely a system can be bent to fit unique business intent.

Building from scratch with AI coding tools: The first 80% of the UI is stunning; the last 20% drags you into the abyss—you must solve hosting, cross-device authentication, row-level database locking, concurrent multi-user editing, and off-site backups yourself. The gap between a solo toy and enterprise collaborative software is fundamentally the cost of governing multi-user state consistency.
Conversational full-stack generators: Easier, with built-in database and public URL—but only a Tech Base. When ten people pile in, who can see purchase prices vs. pick counts? How do you roll back a corrupted recipe? The system collapses.
Traditional low-code builders: Out-of-the-box permissions and buttons, but merely an App Base. They assume your data lives elsewhere; even bundled tables are cold 2D matrices—no discussion bubbles beside rows, no contextual annotations, no collaborative lifecycle.
Vertical industry ERP: Set in concrete. If your mushroom grading standard deviates 10% from factory defaults, the whole system becomes a paperweight.
Malleable work software: A rich data network and collaboration foundation, but historically lacking open "code breakpoints"—non-technical users get stuck when they need to hook up humidity sensors or compute spoilage probability from mycelium color.

Conclusion: no off-the-shelf software fits the personality of a small business 100%.

2. The three-layer ladder of software bases

Malleable software—a concept from HCI pioneers—returns control to users: software is not a locked iron box but clay, reshaped in use. Modern software foundations split into three layers:

1. Tech Base: cloud containers, raw databases, routing, system auth. It knows nothing about "mushroom harvesting." 2. App Base: universal UI controls, API adapters, basic access control. It treats data as a cold external payload. 3. Work Base: the heart of malleable software. Harvest batches, customers, and room environments are interrelated living entities, each automatically carrying permissions, revision history, and discussion context.

Inference: building a Work Base from a Tech Base takes a top engineering team years; adding extension points to a mature Work Base takes only a few quarters.

3. The code comeback: two iron laws

After LLMs flattened the cost of writing code, custom code stormed back. Workers no longer wait for vendor roadmaps—a natural-language prompt can generate a one-tap QC inspection screen for the greenhouse tablet.

But unconstrained code generation is the shortest path to system collapse. Custom code must obey two laws:

Inherit the base unconditionally: read/write automatically respects row-level permissions; state changes enter the audit stream; data-model consistency checks apply.
Sandboxed isolation: a crash never pollutes the core library; exceptions stay within a single UI container; rollback is instant and free.

This is a bounded state machine: custom logic must be a pure function over the base's state evolution:

S_{t+1} = \text{BaseCommit}\Big(S_t, \; \text{Sandbox}\big(f_{\text{code}}(S_t)\big)\Big)

If a tablet app crashes, at worst a worker sees an error dialog—never a deleted database or corrupted inventory.

4. The market inversion: choose your base, not your interface

In a cost analysis of digitizing this 10-person farm, building a collaborative auth foundation from scratch takes over 180 days of engineering, while generating a custom picking interface for a specific tablet now takes under 3 minutes.

For twenty years, vendors charged premiums for beautiful UIs while treating data storage, versioning, and permissions as buried plumbing. Now the world has inverted: the interface is the cheapest, most disposable commodity. A big-button picking mode in the morning, a compact packing list by evening—rebuilt in three minutes. But the Work Base recording years of cultivation lineages, team conversations, and row-level permissions still takes top teams years to harden.

The first rule of software selection: pick your solid foundation; don't be blinded by pretty interfaces.

5. The 2030 mushroom house

We are not heading toward a myth where spoken words conjure complete enterprise systems. LLMs did not eliminate software engineering complexity—they merely dried the cement on the interface layer, making the deeper foundation more visible.

By 2030, we may revisit that straw-scented greenhouse to see whether those ten workers finally abandoned their chaotic Google spreadsheet. Technology won't choose for us: those who waste time reinventing wheels with fresh code will be swallowed by the mud, while those who stand on a solid base and pierce the business frontier with 20% custom code will quietly harvest the richest fruits.

References

1. Dubakov, M. (2026-08-18). *Malleable software = solid bases + custom code*. Edge of Chaos. https://mdubakov.me/malleable-software-solid-bases-custom-code 2. Dubakov, M. (2019). *The No-Code Revolution: Why Now?*. Fibery Blog. https://fibery.com/blog/gems/no-code-revolution-why-now/ 3. Ink & Switch (2019). *End-user programming and malleable software: Capstone essay*. https://www.inkandswitch.com/essay/malleable-software/ 4. Litt, G. (2023). *Malleable software in the age of LLMs*. https://www.geoffreylitt.com/2023/03/25/llm-end-user-programming.html