Refining an idea: from five variants to a direction with a list of things you will not do

A three-phase method for turning a vague idea into a concept to build: expand with a few reasoned variants, converge on one direction, state assumptions and what will not be done.

Methodologymetodologiaideaprodottoingegneria del software19 November 2026 · 3 min read

A newborn idea has an advantage and a flaw. The advantage: it is open, everything seems possible. The flaw: nobody knows what it really is, so everyone builds it their own way. Refining an idea means moving from "a nice intuition" to "a concept a team can build, with its limits written down".

Three phases

1. Understand and restate. You rewrite the idea as a problem in the form of a question ("how might we help people who do X to get Y?"). Then you ask one clarifying question at a time: who it is for, which constraint weighs most, what already exists, what happens if we do not do it. Without the "who for", everything else is fantasy.

2. Expand. You generate five to eight variants, not twenty. Each variant looks at the idea from a different angle: simpler, more ambitious, cheaper, another technology, another audience, an extreme case. A few reasoned variants are worth more than a shower of superficial ideas.

3. Converge. You group the variants that worked into two or three truly different directions. Each direction is tested on three criteria: it serves the people we thought of, it can be done with what we have, and it leaves an advantage over what exists. For each you state the hidden assumptions: what must be true for it to work, and that nobody has verified today.

What you produce

A one-page document with six parts:

  • The problem, in one sentence;
  • The recommended direction, with the reason;
  • The assumptions to validate, each with a way to verify it;
  • The minimum scope (what is done in the first version);
  • What is not done, and why;
  • The questions still open.

The list of what is not done is the most useful part: it protects the first version from the requests added along the way.

The mistakes seen most often

  • Generating twenty superficial variants instead of five considered ones.
  • Skipping the question about who it is for.
  • Choosing a direction without saying which assumptions hold it up.
  • Agreeing with a weak idea out of politeness instead of objecting precisely.
  • Producing a plan without the list of things that are not done.
  • Ignoring the constraints of the existing project when reasoning inside one.
  • Jumping straight to the final document without the two earlier phases.

Tone matters: honest and direct. A facilitator who approves everything is an echo, not a help.

An example

Idea: "an app to report faults on the shop floor". After the "who for" it emerges that the person who sees the fault is the line operator, who has busy hands and a phone in a pocket. The variants range from a simple form to a physical button on the machine. Two directions emerge: a one-tap report on the phone, or an integration with the sensors already there. The assumption to validate for the first: do operators use their personal phone on the floor? The "not done" list for the first version: no automatic assignment to maintenance staff, no statistics.

When to use it

When the idea is still vague, when you need to test the assumptions before committing to a plan, or when it pays to widen the options before narrowing them.

This method derives from the open-source agent-skills family by Addy Osmani (MIT licence), rewritten and adapted.

This article is an OIAR skill

What you have just read is the content of a skill from the OIAR catalogue, written for people. Knowledge like this, but richer and deeper, written for the agents, drives the interviews, the analysis and the report inside the platform. Skills are used in OIAR: to try this one on a project of yours you need an account.

idea-refineA three-phase method for turning a vague idea into a buildable concept: restating it as a problem, five to eight reasoned variants, converging on a direction with assumptions, a minimum scope and a list of what is not done. Use it when the user has a still undefined idea or wants to test it before making a plan.