> ## Content Index
> Fetch the complete content index at: https://vibe2value.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# 1.3.3 - Describe One Main Path First, Then Ignore Everything Else
- URL: https://vibe2value.com/describe-one-main-path-then-ignore-the-rest/
- Published: 2026-01-06T12:11:45.000Z
- Updated: 2026-09-07T05:58:12.000Z
- Description: Describe the main path: describe the user, what starts the flow and the exact steps that lead to the outcome.
- Author: vibe2value
- Tags: shape, strategy, user-journey, simplicity, finding focus, shape+build+launch+run+close

The earlier files describe what the product is, what pain it solves, what it promises and what it is and is not in scope to do. `path.md` is the how: the specific sequence of steps a user takes from the trigger to the promised outcome. The earlier files name the destination; path.md names the route.

## Main path

Is the main path clear enough to ignore the rest?

## The call

Describe one path first. Otherwise AI generates alternatives that split attention before the core flow is proven.

## Sharpen the main path with AI

This is a Shape idea, so the AI move is to **Sharpen** the main path: run your draft through the prompt below until two people would make the same decision from it. Build and Launch ideas have their own AI moves, building and running the code.

**New here? Let your AI do this with you.** Paste your problem into [Guide me](https://vibe2value.com/guide-me/) and it builds a prompt that walks you through this in ChatGPT or Claude. You do not need to know how to prompt.

Prefer to drive the AI yourself? Give ChatGPT or Claude this page and ask it to help. For skill.txt, the Claude Code plugin and other ways in, see [how to use vibe2value](https://vibe2value.com/how-to-use/).

Or copy this prompt into AI chat, replace the bracketed lines with your real main path and keep the instruction exactly as visible here. It helps you put your path.md together by refining your three lines until two people would make the same product decision from them.

```
You are checking whether this main path is clear enough before you move forward.

Constraint:
The main path must be specific enough that two people would design the same flow from it.

Example of the standard:
Vague: "People can use it in a few different ways."
Sharp: "A thought lands and the person with the material emails one line. It goes into their log, and on the rhythm they chose it emails back what is worth saying."
The sharp version is specific enough that two people would design the same flow. The vague one is not.

Working draft:
User: [who the path is for]
Trigger: [what starts the flow]
Path to outcome: [the exact steps that lead to the outcome]

Task:
Decide whether this main path is specific enough that two people would design the same flow. If it already is, say so. If it is vague, rewrite it to meet the standard in the example above.

Check:
- Would two people interpret this the same way?
- Does it stay concrete enough to guide the next step?
- Does it meet this bar: You can describe the user, what starts the flow and the exact steps that lead to the outcome

Return:
- Verdict: clear, or needs work
- The corrected three lines, or the original three if already clear
- What was vague, and the one change that fixed it
```

Copy this into AI chat. Replace the bracketed parts. Keep the rest unchanged. AI will likely suggest refinements based on what you enter. Use those to sharpen your thinking, not replace it.

Choosing one path and deliberately ignoring the rest is a narrowing. Narrowing is what getting to a sharp answer is. That is [Ways to get to a sharp answer](https://vibe2value.com/ways-to-get-to-a-sharp-answer/), one of the [six ways to work with AI](https://vibe2value.com/working-with-ai/).

## The same idea on a recipe card

Picture the numbered steps of a recipe. "Chop, then fry, then simmer, then serve" is one clear route from raw ingredients to a plated meal, and a beginner can follow it. A card that says "you could roast or fry or boil this, in any order you like" leaves the cook frozen at step one.

Your main path is those steps in order. Pick one user, one starting point and one route to the outcome, and write that route down before mapping every other way through. A cook needs one path that works, not a menu of maybes, and so does your first build.

The recipe card is just a simple example, using everyday cooking ideas everyone understands, to make the concept clear. See [the recipe card](https://vibe2value.com/project/recipecard/).

## What it really means

A main path is not the average journey. It is the single route that matters most for the user and the decision in front of you. Until you can point to one user, one trigger and one path to the outcome, attention will keep splitting. AI can help map flows, but it cannot decide which one deserves focus first.

## Make the main path concrete

Compare the broad version with a version you can actually test.

- **Too vague:** People can use it in a few different ways.
- **Concrete enough to test:** A thought lands and the person with the material emails one line. It goes into their log, and on the rhythm they chose it emails back what is worth saying.

The second version lets two people design the same flow from it.

Both versions come from **consideredContent**, the one project carried through all 35 ideas. [See the project](https://vibe2value.com/project/considered-content/).

startside path (later)side path (later)done

The main path is the one route through the product you will describe end to end. The side branches are real, but you grey them out for now, because a clear single path beats three half-drawn ones.

## Check the main path

- **Pass:** You can describe the user, what starts the flow and the exact steps that lead to the outcome.
- **Fail:** If the path still reads like a menu of possibilities instead of one route, it is not focused enough yet.

Do not move into feature, navigation or prototype work until this passes.

## What you'll walk away with

You put this into practice with the prompt above. You'll come out with a main path clear enough that every later decision flows from it. UI choices, what screens exist, what waits for version two and the prompts you write to AI all inherit that clarity.

You write the main path before you build any screen, so every UI decision and AI prompt is anchored against one concrete sequence of steps. The file is called `path.md` because that is what it is: the one path through the product that has to work end to end. The post calls it a "main path" because the act here is choosing one path and consciously ignoring the others.

## Write it down

Your `path.md` is a real file in your project. The AI forgets everything between sessions. It reads this file each time to pick up what you already decided, on this idea or another part of the build. Write it down once instead of explaining it again.

`knowledge-base/framework/shape/path.md` is just a suggested name and place for this information. The name and the location are just how we organise this type of documentation, not something you have to follow. Call the file and put it wherever suits your project. What matters is that it is written down in a format that is easily understood by both people and the AI.

The `.md` ending is markdown, a plain text format often used for documents kept in a code repository like GitHub. It is just the common way people store this kind of writing alongside their code.

Writing it down is how you keep good context for your AI. See [Keep the signal, not the noise](https://vibe2value.com/your-context/) for why this matters across a whole build.

## Risk and mitigation

- **Risk:** Adding side paths too early, which dilutes focus and makes feedback contradictory.
- **Mitigation:** Define one path-level success signal and decline extra routes until that signal is stable.

## Key takeaway

Do not move forward until you can describe the user, what starts the flow and the exact steps that lead to the outcome.

## How to document your main path

Write your main path up in full so your AI has the whole picture: the answer, why you believe it, what you are optimising for, where you might be wrong and the standing instruction it should follow. Keep it in a file with your project like this.

```
# Main path

## Answer
User: [who the path is for]
Trigger: [what starts the flow]
Path to outcome: [the exact steps that lead to the outcome]

## Evidence
Why you believe this. Conversations, examples, tickets, your own experience.

## Decision
What you are optimising for and what you are saying no to.

## Risk
Where you might be wrong and what would tell you.

## AI instruction
The standing note your AI reads on this project.
```

Here is one filled in so you can see what good looks like, grounded in the recipe card idea from earlier.

```
## Answer
User: A beginner cook
Trigger: They have the raw ingredients and want to eat
Path to outcome: Chop, then fry, then simmer, then serve

## Evidence
A beginner following this the first time managed it by sticking to one straight run of steps with no detours.

## Decision
Optimising for one clear path from raw ingredients to a plate. Saying no to variations, substitutions and side dishes for now.

## Risk
They might get stuck if a step assumes knowledge they do not have. Keep each step to a single plain action.

## AI instruction
The one main path is chop, fry, simmer, serve, for a beginner with the ingredients ready. Ignore variations and side dishes until this path works end to end.
```