Mapping the Elephant
Beginner describes a goal ("build a game app"). AI immediately dives into one piece — naming conventions, Unity tutorials, monetization strategy — grabbing "the trunk" while the user holds "an ear." Both are touching the elephant. Neither sees it. The user doesn't have the vocabulary to redirect, so the conversation drifts into a narrow rabbit hole that feels productive but isn't grounded in the whole shape of the problem.
This skill forces a different order of operations: see the whole elephant first, then decide which part to touch.
When someone states a vague goal in an unfamiliar domain, do NOT start helping yet. Start by producing the map:
Before we dive in, let me show you the whole landscape of
"[their goal]" so you know what you're actually stepping into.
Here's every major piece that has to exist for this to work,
in the order they usually get tackled:
1. [Stage name] — what it is, why it exists
2. [Stage name] — what it is, why it exists
3. ...
People in your exact position (no background, starting from zero)
usually get stuck at stage [X] because [reason].
Given that, do you want to:
a) Go broad first (understand every stage lightly before choosing one)
b) Pick a stage now and go deep
c) Tell me more about the idea so I can narrow this map down
This single move — naming the whole shape before acting — is the skill.
Progress:
- Step 1: Detect "elephant-sized ignorance" (user has a goal, zero domain vocabulary, no idea of scope)
- Step 2: Draw the full map of the field (all stages, roles, deliverables, decision points)
- Step 3: Mark where the user's idea currently sits on that map
- Step 4: Surface the 2-4 decision forks that will shape everything downstream
- Step 5: Recommend an entry point based on the user's actual constraints (time, money, skill, goal)
- Step 6: Only then zoom into execution — one stage at a time, always referring back to the map
Step 1: Detect the situation
Signals: "I don't know where to start," "I have an idea but no idea what it needs," "I'm not a [relevant expert]," requests that name an end goal but no process ("I want to launch an app").
Don't treat this like a normal question. Treat it like someone handing you fog.
Step 2: Draw the full map
Produce a field map, not a tutorial. A field map has:
- Stages: the named phases a project like this always goes through (e.g., for a mobile game: concept → scope/platform decision → design → prototype → art → build → testing → store submission → marketing/launch → post-launch ops)
- Roles: who normally does each stage (so the user knows what they'd need to learn, hire, or automate)
- Artifacts: what gets produced at each stage (a doc, a prototype, a build file) — this makes abstract stages concrete
- Forks: the big either/or decisions that change the whole downstream path (e.g., "no-code engine vs. real code," "solo vs. team," "simple game vs. complex game")
Keep it to one screen. Breadth over depth at this point.
Step 3: Locate the idea on the map
Ask or infer: given what they described, which stage are they conceptually at? Usually it's stage 0 — they have a feeling, not even a concept yet. Say so plainly: "Right now you don't have a game idea yet, you have a wish to make a game. Stage 1 is turning the wish into a concept."
Step 4: Surface the forks
Don't list every possible tool or tutorial. List the 2-4 decisions that actually branch the whole project, e.g.:
- Build it yourself (no-code tool) vs. hire/outsource vs. partner with a developer
- Simple/casual game vs. complex game
- iOS+Android native vs. cross-platform Explain the real-world consequence of each choice in plain terms (cost, time, skill needed, ceiling on quality).
Step 5: Recommend based on their actual constraints
Ask directly: budget, time per week, tolerance for learning technical skills, what "success" means to them (hobby, side income, portfolio, full business). Then recommend ONE path. Beginners drown in options; give a default and let them object.
Step 6: Zoom in, but tether every answer to the map
Once they pick a stage to work on, help deeply — but every few exchanges, restate where this fits in the bigger picture ("This step we're doing now is part of stage 3, Prototype — once it's done, next is stage 4"). This prevents the "trunk vs. ear" drift from creeping back in mid-conversation.
Example 1: Input: "I want to build a mobile game app for Play Store and App Store, I'm a plumber, no dev or design background." Output:
Here's the whole landscape before we touch anything:
1. Concept — the actual game idea (1-pager: genre, core loop, why someone plays twice)
2. Scope decision — simple mobile game vs. ambitious game (this changes EVERYTHING downstream)
3. Tooling decision — no-code engine (e.g. visual builders) vs. code-based engine (Unity/Godot) vs. hiring someone
4. Design — levels, art style, sound, UX (someone has to make these decisions even in no-code tools)
5. Build — actually assembling it in the chosen tool
6. Testing — does it work, is it fun, does it crash
7. Store submission — developer accounts, icons, screenshots, age ratings, review process (this alone trips up beginners constantly)
8. Launch & marketing — nobody downloads a game nobody knows exists
9. Post-launch — updates, bug fixes, monetization tuning
You are at stage 0: you have a wish, not yet a concept.
Biggest fork for someone in your position: no-code tool (faster, limited) vs. learning
real development (slower, no ceiling) vs. hiring a developer (fastest, costs money, you
manage instead of build).
Given you've said you have no dev/design background and didn't mention budget — what's
your time availability per week, and is this a hobby project or something you want to
make money from? That tells me which path to recommend.
Example 2: Input: "I want to start a podcast but have no idea what that involves." Output: Map stages (format/niche decision → equipment → recording → editing → hosting platform → distribution/RSS → cover art & metadata → launch → growth), name the forks (solo vs. co-host, video vs. audio-only, raw vs. heavily edited), locate them at stage 0, ask about time/budget/goal, recommend one path.
- Always map before you help. Resist the pull to answer the literal first question asked — it's almost always a trunk when the user needs the elephant.
- Use plain language stage names, not jargon. "Getting your app onto the store" not "ASO and build pipeline."
- Keep the map short. One screen, 5-10 stages max. A map with 40 bullet points is just a new jungle.
- Always end the mapping phase with a question that narrows based on real constraints (time, money, goal) — don't leave the user facing an open menu.
- Re-anchor periodically. Every significant chunk of deep-dive work, restate the stage name so the user never loses the thread.
- Name the stage where beginners typically fail (e.g., store submission paperwork, or "nobody finds the game after launch") — this alone is often the most valuable sentence in the whole map, since it's invisible to beginners until they hit it.
- Jumping straight into tool recommendations ("use Unity, here's a tutorial") before the user knows if coding is even the right fork for them.
- Dumping an exhaustive list of every tool/platform/resource — overwhelms exactly like Google search did. The map should simplify, not multiply options.
- Asking twenty clarifying questions up front. Give the map first (it's cheap, build trust and context), then ask only the 1-3 questions that actually change the recommendation.
- Forgetting to re-anchor. Without periodic reminders of "where we are," long conversations drift back into trunk-vs-ear territory.
- Treating the user's lack of vocabulary as lack of intelligence. Translate jargon, don't dumb down the thinking.