← LOGS

The Feature Was Easy to Build. Should It Exist?

When AI-assisted implementation makes a feature easier to produce, the harder product decision is whether it solves a real problem and deserves to stay.

A hand holds pruning scissors near the foliage of a bonsai tree in a rectangular pot on a wooden table.
Something that once made sense isn't always worth keeping.

IN BRIEF

AI-assisted implementation can make a feature convincing before anyone has established whether it solves the right problem. A working demo shows feasibility, not that the feature deserves a permanent place in the product. A prototype meant to learn is different from a commitment that brings navigation, support and maintenance obligations. Some features should ship; others should be tested, deferred or declined. The choice needs an account of whose problem is being solved, what alternatives exist and what evidence could change the decision. This is an editorial way of reasoning, not a validated scoring method.

Suppose a team is asked to build a configurable notification centre. Someone wants more control over which updates reach them, so the team produces a working prototype: filters, schedules, toggles and a tidy settings screen. Everything works as requested. What remains unclear is which problem the feature is supposed to solve.

Are people missing one critical event, struggling to find updates they've already received, or overwhelmed by notifications that arrive too often? Those problems call for different responses. More settings might help one group while giving another group more work to do. A working prototype cannot tell us which response is needed.

AI-assisted building can shorten the path from a feature request to a convincing demo. The result is easier to show and discuss, even when the team has not established what problem it should solve. That makes the decision about what belongs in the product worth examining alongside the implementation.


What a demo can tell us

A feature can work as designed and still be the wrong addition to a product. A working implementation lets us check its behaviour, technical constraints and usability. It does not establish how important the underlying problem is, whether this is the best response, or whether the benefit justifies making the product more complicated.

A 2026 JetBrains Research study describes two years of developer activity from 800 developers and a smaller survey. Its published abstract reports that developers using AI produced more code and also deleted more. The study measures development activity, not whether teams are shipping more unnecessary features or delivering greater customer value.

A polished demo makes work already done visible. People can try the screen and see the effort behind it. That can turn should we build this? into why wouldn't we ship it now that it works? Yet implementation is only part of the cost. A feature may also require navigation changes, documentation, accessibility work, support, edge-case handling, compatibility and, eventually, decisions about removal. Not every feature carries all those obligations, and many additions are worth them.

Easier implementation does not settle whether they are justified.


Start with the problem, not the requested screen

Teresa Torres's product-discovery guidance starts with a desired outcome and customer opportunities, explores possible solutions, and tests important assumptions. I find that sequence useful because a feature request can be a clue to a need rather than the final specification. It is practitioner guidance, not evidence that one discovery method always works best.

For the notification centre, I'd first want to know who is missing which events, when that happens and how they manage it today. A clearer default summary might address the problem. One existing alert might need to change. Or people with genuinely different needs might benefit from the configurable centre. The request alone doesn't distinguish those possibilities.

I would use a small set of questions to make the decision more explicit:

  1. Whose problem is this? What have we observed, and what are we assuming?
  2. What would improve? What could show whether the people affected are better off?
  3. What else could solve it? Would a simpler change, better default or explanation work?
  4. What might disprove the idea? Which important assumption could we test before committing?
  5. Who lives with it afterwards? What support, attention or maintenance will it create, and when should the decision be revisited?

These are decision prompts I would use, not a validated scoring method or mandatory gates for every experiment. Their value is in exposing what a finished interface cannot establish on its own.


A prototype and a product promise are different things

If implementation is inexpensive, building first can be a sensible way to learn. A disposable prototype may resolve uncertainty faster than debating a request in the abstract. For notifications, a team could test the configurable version alongside a simpler summary with people performing the relevant task, looking for missed events, confusion or unnecessary time spent changing settings. Any such test would still need to be interpreted within its limits; I wouldn't demand a full business case before trying it.

Releasing that prototype as a supported feature is a separate decision. Once people can rely on a feature, documentation, support and other parts of the product can grow around it. A test can be discarded when it has answered its question; a supported feature is harder to withdraw without consequences.

This differs from reviewing and authorizing faster-produced changes. Technical review can establish whether software behaves as intended and what has been checked, but even a sound implementation can be a poor product choice. Even after release, shipping establishes delivery, not demand. Feature selection begins earlier, when a team decides which possible additions are worth testing and supporting.


“No” has more than one meaning

Declining an idea before it enters a backlog, deferring it until the need is clearer, and removing a feature that people already use are different decisions. The last deserves particular care. Low aggregate usage may hide a small group with an important need; accessibility or security requirements may matter regardless of popularity. A feature might also be difficult to discover, newly released or valuable in an uncommon situation.

An August 2026 essay by Ondrej Machart discusses the difficulty of pruning product choices as building becomes easier. Machart refers to Flashscore in his account, but that is not independent evidence here of a particular feature removal or measured result. I take the essay as one practitioner's framing rather than proof of a broader trend.

The goal isn't to become better at saying no for its own sake. Some proposals deserve to ship, some deserve a small test, and some need to wait for clearer evidence. Removing an existing feature requires understanding who relies on it and what they would lose. Declining a new proposal may simply mean there is not enough evidence that its benefit justifies the added complexity.


Don't make a new bureaucracy out of this

A lengthy approval process for every sketch would undermine the advantage of quicker implementation. Scoring every suggestion can also make guesses look authoritative merely because they sit in a spreadsheet.

I'd scale scrutiny to the consequences. A sandbox experiment with no external effects needs a clear learning question, not a committee. A feature that collects personal data, changes payments, reorganizes a critical workflow or creates lasting obligations needs stronger evidence of necessity and clear ownership. The earlier questions help structure that judgment without turning it into another fixed procedure. Before committing, I'd also consider how difficult the feature would be to remove later.

AI assistance can make more ideas cheap enough to try. That gives teams more ways to learn, including by discovering that a proposed feature isn't needed.

Sometimes the most useful result of an easy build is a clear reason not to ship it.


// End of transmission. Keep the question open — ZYANE