Malleable Software: The Synergy of Solid Bases and Custom Code

By Michael Dubakov | August 18, 2026

In 2019, I placed a significant bet on the rise of the no-code revolution. Having operated within the productivity tools sector since 2004, I've spent over two decades analyzing market trends. Periodically, when the landscape shifts, I publish a "visionary" synthesis of where things are headed.

We have reached another such inflection point. The market is currently undergoing tectonic shifts that will fundamentally redefine how we build and use software.

The AI Catalyst and the "Vibe-Coding" Era

It is common knowledge that AI has demolished the entry barrier to software development. Today, almost anyone can create a functional tool. While we aren't yet at the stage where you can "vibe-code" a complete operating system, creating small, personal utility apps via prompting is now trivial.

However, complexity spikes the moment you introduce collaboration.

When building for yourself, breaking things is part of the iterative process. But for a team, you need a robust infrastructure to handle:

• Relational data storage
• Concurrent multi-user editing
• Notification systems
• Version history and audit logs
• Granular permission sets

This leads to a pivotal question: Where does the "sweet spot" for malleable software lie in the age of AI? Should we be building from scratch, or utilizing a solid base that can be refined with custom code?

---

The Mushroom Farm Scenario

Imagine a small-scale mushroom operation (growing champignons) with 10 employees. They need a system to manage their entire workflow. Because the niche is too small for dedicated industry software, they likely rely on Google Sheets.

If they try to build a custom solution, they face several paths:

1. Prompt-coding from the ground up

You use AI to write every line.

• The Struggle: You are responsible for everything—hosting, auth, database schemas, and permissions.
• The Pareto Problem: The first 80% of the build is a breeze; the final 20% is a nightmare.

Future Hope: Eventually, AI will become so sophisticated that it handles the "boring" infrastructure perfectly and instantaneously.

2. Vibe-coding Platforms (e.g., Lovable, v0)

These emerged around 2023 and offer a more polished start.

• The Benefit: You get a hosted environment, database, and authentication out of the box.
• The Struggle: Once you exceed the capabilities of the generator, you hit a wall.

Future Hope: Better models and the addition of more modular components will push these tools toward a "solid base + custom code" model.

3. Low-code App Builders (e.g., Retool, Softr)

These have championed the "base + code" approach since 2017.

• The Benefit: Built-in audit logs, hosting, and access control.
• The Struggle: They assume your data lives elsewhere. Even with internal databases, they often lack "work-level" collaboration (like inline comments or change history).

Future Hope: These tools will evolve to provide a deeper, more integrated "work base."

4. Malleable Tools (e.g., Notion, Fibery)

These have been around since 2013 and offer high flexibility.

• The Benefit: Rapid deployment of a functional workspace.
• The Struggle: They can be too rigid for highly specific needs and often lack sufficient extension points.

Future Hope: By adding more extension points and allowing "vibe-coding" for the final 20% of use cases, these tools will merge into the "solid base + custom code" category.

5. Specialized Off-the-Shelf Software

The traditional model since 1999.

• The Benefit: Built specifically for your domain.
• The Struggle: Zero flexibility. If you need a custom tweak, you're out of luck.

Future Hope: These vendors likely won't become flexible tools—and they don't need to. Once a tool becomes generically flexible, it loses its "specialized" identity.

---

The Formula for Productivity Tools

The ideal architecture for modern productivity software can be expressed as:

$\text{Malleable Software} = \text{80\% Solid Base} + \text{20\% Custom Code}$

The goal is to have a foundation that handles the universal requirements of any team, while allowing the user to inject the specific logic that makes their business unique.

Understanding the "Solid Base"

In the early days, your only "solid bases" were the OS and the compiler. Today, bases come in different flavors:

The Power of the 20% (Custom Code)

While the base covers the commonalities, the custom code handles the unique identity of your company. This includes:

• Unique Interfaces: e.g., A specialized harvest dashboard for a tablet in the growing room.
• Business Logic: e.g., Specific quality control rules for mushroom batches.
• Integrations: e.g., Connecting to a wholesale client's API or IoT humidity sensors.

This 20% is small in volume but represents the actual value of your business. No vendor can model every unique business process perfectly.

Visualizing the Evolution

The "Final 20%" Checklist

To move from a prototype to a professional tool, you must complete these tasks:

• Implement robust auth and permissions.
• Establish a relational database schema.
• Set up a reliable hosting environment.
• Build custom business logic for domain-specific rules.
• Integrate with external APIs/Sensors.

Conclusion: The Great Irony

The most surprising development is that code has made a comeback. By the end of 2025, LLMs made coding accessible enough that no-code and low-code tools are ironically leaning more on custom code to provide the flexibility users crave.

Additional Resources

// Example of the "20% Custom Code" for the Mushroom Farm
function validateBatchQuality(humidity, temperature) {
    if (humidity < 80 || temperature > 25) {
        return "Alert: Environmental stress detected in Growing Room A";
    }
    return "Batch quality optimal";
}