Pre-installed applications on modern operating systems are considered bloated by many users. A case currently under discussion makes this tangible: a developer was unhappy with the resource consumption of the Weather app on Windows 11 and promptly built his own version — with the support of the AI assistant Claude. Instead of around 700 megabytes, his solution reportedly uses about 70 megabytes.

The case is small, the underlying question is not. When a single developer produces a lean, precisely fitting application in one evening, the economic calculation between buying and building shifts.

What is meant by vibe coding

The term vibe coding describes a way of working in which software is created predominantly in dialogue with a language model: you describe in natural language what the application should do, have code generated, test it, describe the deviation and iterate. The developer therefore steers more through intent and review than through every individual line.

This significantly lowers the barrier to entry for small tools. Applications whose in-house development would never have paid off before — a status window, an import script, an internal converter — suddenly fall within the scope of a few hours.

Why standard software is often heavy

Large, universally applicable applications carry functions that a single business never needs: multilingual support, telemetry, advertising space, synchronisation services, configuration interfaces for dozens of special cases. Each of these functions costs memory, start-up time and attack surface.

A custom solution that fulfils exactly one task can be considerably smaller — not because it would be better programmed, but because it can do less. That is precisely where its advantage lies and at the same time its risk.

The calculation does not always work out

Today, building is the cheapest part of a software life cycle. Everything afterwards remains expensive:

  • Maintenance: operating system updates, changed interfaces and expired libraries also affect small tools.
  • Security: those who build themselves are themselves responsible for ensuring that dependencies are up to date and inputs are validated.
  • Dependence on individuals: a tool that only one person understands becomes a problem at the next change of role.
  • Documentation: without traceable decisions, generated code is also someone else's code after six months.

Accordingly, attempting to replace a CRM or ERP system in this way is not a sensible conclusion to draw from a weather window. The more a system carries regulatory requirements, many user roles or long-lived data, the more the balance continues to favour proven standard software.

Where building your own realistically pays off

AI-supported in-house development typically makes sense where a task is clearly defined and no market exists for it that would bear the effort:

  • internal auxiliary tools that transform data between two systems
  • evaluations that are currently laboriously created by hand in spreadsheets
  • small interfaces for specialist departments that make an existing interface usable
  • prototypes that make a requirement visible before a larger project is commissioned

The last point in particular is underestimated. A working prototype clarifies requirements faster than three rounds of consultation on a concept document — and can subsequently be deliberately discarded.

Guard rails for operation

To prevent productive individual initiatives from turning into an uncontrolled tool landscape, a simple framework helps. Three questions are enough to start with:

  1. Data class: Does the tool process personal or business-critical data? Then the same rules apply as for purchased software.
  2. User group: Does it remain a single workstation, or does it become part of a process that others rely on?
  3. Exit path: What happens if the person who built it is no longer available?

Anyone who answers these questions in writing can deliberately keep small solutions lightweight — and recognises early when a tool must make the leap into regular development with version control, code review and deployment process.

Quality remains a human task

Generated code is not automatically bad code, but it is unreviewed code. Responsibility for architecture, security and readability shifts from writing to evaluating. That still requires expertise — just at a different point in the process.

The case described is therefore less suitable as proof that standard software is becoming superfluous, but rather as an indication that the threshold for precisely tailored custom solutions has fallen significantly.

Assessment for web and software projects

For projects, this above all means a more honest make-or-buy decision: the decisive argument is no longer the development effort, but the question of who will maintain the result over the years.

Small, clearly delineated tools can now be built economically in-house and should deliberately be treated as such — with a defined purpose, documented dependencies and a planned end. For supporting systems, however, the established path remains the right one, with AI support there above all freeing up time for prototypes, migration scripts and routine tasks.

Sources