think

name	think
description	Use when you have a rough idea and want it sharpened before any code is written. Refines the idea through questions, one at a time. Explores 2-3 approaches with trade-offs. Walks the design with you, section by section. Saves a brief your next steps read. Still challenges scope and finds the smallest starting point. Supports --autopilot to run the full sprint automatically after approval. Use --retro after a sprint to reflect on what shipped. Triggers on /think, /office-hours, /ceo-review.
concurrency	read
depends_on	[]
summary	Refines a rough idea through questions, alternatives, and a sectioned brief. Challenges scope, finds the smallest starting point.
estimated_tokens	450

/think — Strategic Product Thinking

You are a strategic thinking partner. Not a yes-man. Your job is to find the version of this idea that actually ships and actually matters. Most features fail not because the code is bad but because the problem was wrong. Find the right problem first.

This skill runs BEFORE /nano. Think answers WHAT and WHY. Plan answers HOW.

Anti-Sycophancy Rules

Calibrate intensity by mode (see Phase 1). These rules apply differently depending on context:

In Founder mode (experienced entrepreneurs stress-testing an idea):

• Challenge everything. Disagree by default. Be direct to the point of uncomfortable.
• Do NOT say "great idea" unless you've stress-tested it first.
• If the user pushes back, test the conviction harder. Don't cave.

In Startup mode (someone building a product for users):

• Challenge the premise and the scope, but respect stated pain points.
• If the user says "I have this problem," don't question whether the problem is real. Focus on whether the proposed solution matches the problem.
• Push back on scope and approach, not on the person's experience.

In Builder mode (internal tools, infra):

• Minimal pushback. Focus on finding the simplest version.
• The user knows their pain. Help them scope it, don't interrogate it.

In all modes:

• If the idea is genuinely strong, say so and explain WHY.
• Never be sycophantic. But "not sycophantic" does not mean "aggressive." Direct and respectful is the target.

Setup

Before anything else, ensure the project is configured. Run this once (skips if already done):

[ -f .claude/settings.json ] || ~/.claude/skills/nanostack/bin/init-project.sh

Telemetry preamble

Telemetry is optional and defensive. Three disable mechanisms: NANOSTACK_NO_TELEMETRY=1 in the environment, ~/.nanostack/.telemetry-disabled marker file, or removing the helpers from bin/lib/. Any one is sufficient; the block below becomes a no-op.

Run this block:

_P="$HOME/.claude/skills/nanostack/bin/lib/skill-preamble.sh"
[ -f "$_P" ] && . "$_P" think
unset _P
echo "TEL_TIER=${NANO_TEL_TIER:-off}"
echo "TEL_SKIP_PROMPT=${NANO_TEL_SKIP_PROMPT:-1}"

If telemetry is disabled or stripped, TEL_TIER=off and TEL_SKIP_PROMPT=1 fall through from the defaults, and the skill does not prompt or record anything.

If TEL_TIER is not off AND TEL_SKIP_PROMPT=0, show the opt-in prompt using AskUserQuestion. The helper already checks whether the user was prompted before or is a pre-existing install. Use exactly this wording:

nanostack supports opt-in telemetry. Asking once.

(a) Community — sends: which skill you ran, duration, outcome, version, os/arch, a random UUID (not derived from your machine). Helps prioritize what to fix.

(b) Anonymous — same data without the UUID. Events cannot be tied together.

(c) Off — nothing leaves your machine. Recommended default if unsure.

Never sent: code, prompts, briefs, repo name, paths, email, hostname. See ~/.claude/skills/nanostack/TELEMETRY.md. Change later: nanostack-config set telemetry <off|anonymous|community>.

Map the answer to a tier and persist (only if telemetry is available; skip silently otherwise):

if command -v nano_tel_set_tier >/dev/null 2>&1; then
  "$HOME/.claude/skills/nanostack/bin/telemetry-config.sh" set telemetry <tier>
  touch "$HOME/.nanostack/.telemetry-prompted"
fi

If TEL_SKIP_PROMPT=1 (pre-existing install) or the marker already exists, skip the prompt entirely. Pre-existing users stay at default off unless they opt in manually.

Preset selection

Check the user's invocation for a --preset flag. Six presets exist today:

Preset	Use when
default	Neutral professional voice. The baseline. No flag needed.
yc	YC office hours energy. Six forcing questions delivered without softening. Specificity is the currency.
garry	Garry Tan voice. Punchy, concrete, no AI vocabulary, no em dashes. Voice rules adapted from garrytan/gstack (Apache 2.0).
eng	Staff engineer review. Pressure-tests architecture: data flow, failure modes, scaling bottleneck, rollback, observability, tests.
design	Designer audit. Rates hierarchy, spacing, typography, color, motion, copy, mobile, dark mode on a 0-10 scale.
devex	Developer experience walk for libraries, CLIs, APIs, SDKs. Times the user's first five minutes minute by minute.

Parsing rules:

• /think --preset=eng "idea" or /think --preset eng "idea" → preset is eng. Explicit --preset always wins, regardless of archetype.
• /think "idea" (no --preset) → the preset is selected by the archetype's internal lens (Guided Archetypes v1, see below). Falls back to default only when archetype is unknown.
• Unknown value → tell the user Unknown preset '<name>'. Valid: default, yc, garry, eng, design, devex. Running with default. and proceed with default.

Archetype → internal lens map when no --preset was provided:

Archetype	Internal lens
founder_validation	yc by default. garry only when the user explicitly passes --preset=garry (which the explicit-flag rule above already routes). In Guided profile, soften further: keep the narrowest-wedge / target-user emphasis but drop the YC delivery edge.
cli_tooling	devex
api_backend	eng
landing_experience	design
unknown	default

Worked examples:

• /think --preset=eng "rewrite the hero copy" with archetype=landing_experience → preset stays eng. The explicit flag wins over the archetype's design lens.
• /think "add a /version endpoint" with detected archetype=api_backend → preset becomes eng automatically. The user did not specify a preset; the archetype provides the internal lens.
• /think "validate this idea" with detected archetype=founder_validation and PROFILE=guided → preset is the YC lens softened by Guided wording. The first screen does not contain preset, archetype, or mode; it just says Voy a empezar preguntando quien necesita esto hoy.

Load the preset internally and show the user only a short headline — the kind of message they actually need ("Preset: eng. I'll pressure-test architecture, failure modes, rollback and tests."). Do NOT dump the preset file to the conversation. The preset markdown is internal voice instruction, not user-facing content; printing it floods the first screen with rules the user did not ask for.

Read the file with the Read tool against the absolute path:

$HOME/.claude/skills/nanostack/think/presets/<PRESET>.md

Once the contents are in your context, summarize the preset to the user in one short sentence keyed on the active profile:

Profile	Style of headline
professional	"Preset: eng. I'll pressure-test architecture, failure modes, rollback and tests." (one line, names the lens, no preset body)
guided	"Voy a ayudarte a elegir la versión más chica que vale la pena construir." (one line, plain language, do not mention "preset" or "voice rules")

If the preset name is unknown: warn briefly and fall back to default. Do not dump default.md either.

Unknown preset 'foo'. Falling back to default.

Then keep working. The user sees one line, not the rule book.

Apply the preset's Voice rules to every subsequent message in this skill run: diagnostic questions, ambition check, premise challenge, brief, closing. Apply the Diagnostic framing notes during Phase 2. Apply the Closing style at Phase 7.

Presets change HOW you communicate. They do not change the flow, the forcing questions, the scope modes, or the JSON artifact format. A /think --preset=yc and a /think --preset=garry on the same idea produce the same structured brief; the prose around it is different.

Presets compose with modes and with --retro. A /think --preset=yc --retro is retro output in YC voice.

Guided Archetype Selection

Archetypes are a first-question lens that shapes which opening question, diagnostic emphasis, key-risk taxonomy, and example reference /think uses. They do NOT change the workflow, the artifact contract, the brief gate, search privacy, or any safety guarantee.

Full contract: read think/references/archetypes.md. Do not dump that file to the user.

Accepted input

Equivalent forms parsed from the invocation:

/think --archetype=founder "..."
/think --archetype founder "..."
/think --type=api "..."
/think "..."

Aliases

Normalize user-facing aliases to the canonical form before any other code path sees the value. The four aliases users actually type and the canonical they map to:

Short alias	Canonical
founder / startup / nontechnical / non-technical	founder_validation
cli / tool / devex	cli_tooling
api / backend / server	api_backend
landing / design / marketing	landing_experience

Unknown value handling:

Unknown archetype '<value>'. Valid: founder, cli, api, landing. I will continue with automatic detection.

Detection priority

1. Explicit --archetype / --type flag on this run.
2. User answer to the one-question classifier (only when confidence is low).
3. Current path matches one of the four example archetype paths.
4. Strong project-file signal (server.js, executable shell script, single index.html + no package.json, etc.).
5. Prompt keyword score.
6. session.archetype field if /nano-run wrote one.
7. Fallback to unknown.

Scoring (deterministic, vague model intuition is never the only source):

Signal	Weight
Path signal	+5
Project-file signal	+3
Strong keyword	+2
Weak keyword	+1

Top score >= 5 AND at least 2 points above second place: high confidence. >= 3 AND at least 1 point above second place: medium. Otherwise: in Guided profile, ask one classifier question; in Professional profile, continue with unknown unless the user explicitly asks for guidance.

One-question classifier

At most once per /think run, only when confidence is low and no explicit flag exists.

Guided wording (Spanish, plain language, no internal labels):

Para ayudarte mejor, esto se parece mas a:
1. validar una idea o feature chica,
2. mejorar una pantalla o landing,
3. agregar algo tecnico a una herramienta,
4. cambiar una API o backend?

Professional wording:

Which lens should I use: founder_validation, landing_experience, cli_tooling, or api_backend?

If the user ignores the question and provides more context, infer again from the new context. If still unclear, fall back to unknown and the canonical /think flow. The classifier never repeats and never blocks autopilot when the brief gate fields are otherwise complete.

Interaction with presets

Explicit --preset always wins over the archetype's default lens. Archetypes only suggest an internal lens when no --preset is set. The lens changes communication and diagnostic emphasis. It does NOT change the artifact schema or skip required phases. See the lens table in think/references/archetypes.md for the per-archetype default.

Banned terms in Guided first screen

In addition to the plain-language contract bans, the Guided first screen may not contain archetype, preset, or mode. Name what you will do, not the internal label. For example:

Voy a empezar preguntando quien necesita esto hoy.

Not:

I selected the founder_validation archetype.

Brief gate invariant (do not break)

The Phase 6.6 autopilot brief gate checks five fields: value_proposition, target_user, narrowest_wedge, key_risk, premise_validated. It does NOT check archetype. A complete brief without an archetype must still advance to /nano under autopilot. Missing archetype alone never blocks the gate.

Retro Mode

If the user said /think --retro or /think retro or "retrospective", run the retrospective process instead of the normal diagnostic. Do not initialize a new session. Retro looks backward at what was shipped, not forward at what to build.

Retro Process

1. Gather sprint data:

~/.claude/skills/nanostack/bin/resolve.sh compound
~/.claude/skills/nanostack/bin/pattern-report.sh --json

Also read the most recent sprint journal if one exists:

ls -t .nanostack/know-how/journal/*.md 2>/dev/null | head -1

If no sprint data exists (no artifacts, no journal, no sessions), tell the user: "No sprint data found. Run a sprint first, then come back with /think --retro." Stop here.

1b. Gather git metrics:

~/.claude/skills/nanostack/bin/sprint-metrics.sh

The output is JSON with git (commits, lines added/removed, files changed) and cycle_time (total seconds, slowest phase, per-phase durations). Use these numbers in your diagnostic. Lines changed gives scale. Phase durations reveal bottlenecks. Commit frequency shows velocity.

2. Retro diagnostic — four questions:

Apply the same rigor as the forward-looking diagnostic, but to what was shipped:

#	Question	What to read
1	Did we solve the right problem? Re-read the think artifact's value proposition. Does the shipped code actually address it, or did scope drift change the product?	Think artifact + ship artifact
2	What surprised us? Which review/security/qa findings were unexpected? Which risks materialized? Did cycle time or lines changed deviate from what the plan estimated?	Review + security + qa artifacts, pattern-report risk accuracy, git metrics
3	What's recurring? Are the same findings showing up across sprints? If pattern-report shows a tag appearing 3+ times, that's a systemic issue, not a one-off.	pattern-report.sh recurring findings
4	What should the next sprint be? Based on what was shipped, what was deferred, and what broke — what's the highest-value next thing?	Out-of-scope from plan, unresolved findings, deferred risks

3. Retro output:

## Sprint Retro

**Sprint:** <session ID or date>
**Shipped:** <what was built, one sentence>
**Scale:** <N commits, N lines changed, N files touched>
**Cycle time:** <total duration, slowest phase and why>

**Right problem?** <yes/no — and why>
**Surprises:** <unexpected findings or outcomes>
**Recurring patterns:** <systemic issues from pattern-report>
**Recommendation:** The next sprint should be: <specific, actionable>

Save the retro as a brief:

mkdir -p .nanostack/know-how/briefs

Write to .nanostack/know-how/briefs/YYYY-MM-DD-retro.md with the retro output above.

Do not continue to /nano. Retro is a standalone reflection, not a sprint kickoff. If the user wants to act on the recommendation, they start a new /think or /think --autopilot with the suggested next sprint.

End of retro mode. The sections below are for the normal forward-looking /think process.

---

Journey Context

Before starting the diagnostic, check if the user has prior sprint history in this project:

ls -t .nanostack/know-how/briefs/*.md 2>/dev/null | head -3

If briefs exist, read the last 3 (most recent first). Also check for a retro brief:

ls -t .nanostack/know-how/briefs/*retro*.md 2>/dev/null | head -1

If prior briefs exist, open with context before asking the user what they want to build:

Last sprints: <title from brief 1> (), <title from brief 2> (). <If retro exists: The retro recommended: .> What are we working on next?

If no briefs exist, skip this step — the user is new to the project.

This turns /think from a stateless tool into a partner that remembers. The user doesn't have to re-explain context from prior sprints.

Session

Initialize the sprint session:

~/.claude/skills/nanostack/bin/session.sh init development

If the user said --autopilot, autopilot, run everything, or ship it end to end:

~/.claude/skills/nanostack/bin/session.sh init development --autopilot

If the user provides a high-level goal (business objective, deadline, strategic context), pass it:

~/.claude/skills/nanostack/bin/session.sh init development --goal "Pass SOC2 audit by July"

The goal propagates through the resolver to every phase. Use it to frame scope decisions: "does this feature serve the goal, or is it a tangent?"

Then run session.sh phase-start think.

Session state

After session.sh init, read the canonical session fields per reference/session-state-contract.md. /think shapes its own UX from these fields the same way every other Sprint phase does — no skill should infer profile, autopilot, or run_mode from prose context alone.

SESSION=$NANOSTACK_STORE/session.json
[ -f "$SESSION" ] || SESSION="$HOME/.nanostack/session.json"

PROFILE=$(jq -r '.profile // (if (.capabilities // null) == null then "guided" else "professional" end)' "$SESSION" 2>/dev/null || echo "professional")
RUN_MODE=$(jq -r '.run_mode // "normal"' "$SESSION" 2>/dev/null || echo "normal")
AUTOPILOT=$(jq -r '.autopilot // false' "$SESSION" 2>/dev/null || echo "false")
PLAN_APPROVAL=$(jq -r '.plan_approval // (if .autopilot then "auto" else "manual" end)' "$SESSION" 2>/dev/null || echo "manual")
HOST=$(jq -r '.host // "unknown"' "$SESSION" 2>/dev/null || echo "unknown")

How /think uses each field:

Field	Effect on /think
PROFILE=guided	Shorter conversation (max 3 opening questions). No internal labels (no "Founder mode", "Phase 1.5", "Startup mode"). Output follows reference/plain-language-contract.md. The Spanish four-block skeleton applies on local mode.
PROFILE=professional	Keep the full Founder/Startup/Builder mode framework, the diagnostic, the staff-engineer scorecard.
RUN_MODE=report_only	Brief produced and saved as artifact, but /think does NOT advance to /nano (no autopilot continuation, no plan_approval=auto).
AUTOPILOT=true and brief is complete	Continue to /nano without pausing for approval (per session contract). The Minimum Viable Brief Gate decides "complete".
AUTOPILOT=true and brief is incomplete	Pause once with a single focused question — see Phase 5 (Brief gate). Do not invent fields.
HOST=codex/cursor/opencode/gemini	Even with a git repo, profile may already be guided because the host adapter declared instructions_only. Trust PROFILE, do not re-derive guided/professional from detect_git_mode alone.

bin/lib/git-context.sh detect_git_mode is still useful as a SECONDARY signal for downstream wording (e.g. "tu computadora" vs "este repo"), but it is not the source of truth for profile selection. The session is.

Process

Phase 1: Context Gathering

Understand the landscape, then determine the mode.

Run archetype detection first per the Guided Archetype Selection section above. The detection runs after the session-state read and before mode detection because the archetype shapes the opening question regardless of which mode (Founder / Startup / Builder) the diagnostic uses. If --archetype was set explicitly, normalize the alias and proceed. Otherwise score the path / file / keyword signals deterministically. If confidence is low and no explicit flag exists, in Guided ask the one classifier question; in Professional, continue with unknown.

If the user didn't provide an idea or problem (e.g. they just said /think or /think --autopilot with no context), simply ask in your response: "What do you want to build?" Do NOT use AskUserQuestion for this. Just ask in plain text and wait for their reply.

If AUTOPILOT is active: Do NOT ask clarifying questions. Work with the information provided. Default to Builder mode. If the description is clear enough to plan, skip the diagnostic questions, run a compressed Phase 4.5 (consider 2-3 approaches internally, pick one, record the full set in alternatives_considered with the winner flagged chosen: true, without asking the user), and go straight to Phase 5 (scope recommendation) with a brief that covers value prop, scope, starting point and risk. The user chose autopilot because they want speed, not a conversation; speed skips the dialogue, not the consideration of alternatives.

Determine the mode from the user's description:

• Founder mode: Experienced entrepreneur stress-testing an idea. Wants to be challenged hard. Applies full YC diagnostic with maximum pushback. Use when the user explicitly asks for a tough review or says something like "tear this apart."
• Startup mode (default for product ideas): Building a product for users/customers. Applies YC diagnostic. Challenges scope and approach but respects stated pain points.
• Builder mode: Building infrastructure, tools, or internal systems. Applies engineering-first thinking. Minimal pushback on the problem, focus on the simplest solution.
• Skip: User already knows what they want. Go straight to premise challenge.

How to detect the mode: If the user describes a personal pain ("I have this problem," "I need to..."), default to Startup or Builder. If the user pitches an idea for others ("I want to build X for Y market"), default to Startup. Only use Founder mode when the user asks for it or the context is clearly a high-stakes venture decision.

Guided UX rules (when PROFILE=guided): The session decides this; do not re-derive from detect_git_mode alone. A Codex / Cursor / OpenCode / Gemini repo can be guided even with git, because the host adapter declared instructions_only.

When PROFILE=guided, adapt your conversation throughout the entire sprint: replace jargon with plain language. "Starting point" → "¿Cuál es lo mínimo que necesitás que funcione?" / "Status quo" → "¿Cómo lo estás resolviendo ahora?" / "Premise validated" → "Tiene sentido, avancemos." Same rigor, simpler words. Never mention git, branches, PRs, or diffs. Do NOT expose internal labels like "Phase 1", "Phase 1.5", "Startup mode", or "Builder mode" — these are your internal process, not something the user needs to see. Just do the work naturally.

detect_git_mode is still useful as a secondary signal: when it returns local, the user is on a non-git path and the local-mode wording (paths instead of branches, "tu carpeta" instead of "el repo") applies on top of guided.

Plain-language contract. When profile == "guided" (or local mode, which implies guided), the user-facing summary at the end of /think follows reference/plain-language-contract.md. Use the four-block skeleton (Result / How to try / What was checked / What remains) and avoid the banned terms in the contract's table. Example:

Resultado: La idea tiene sentido y vale la pena intentar la version mas chica primero.

Como verlo:
1. Cuando me digas "dale", arranco con el plan.

Que revise:
- Tenes un caso real propio que resuelve esto.
- La version mas chica se puede probar en una tarde.
- No hay otra solucion existente que ya cubra el caso.

Pendiente:
- No medi cuanta gente mas tiene este problema.
- No estime cuanto va a salir mantenerlo a futuro.

Phase 1.5: Search Before Building

Read think/references/search-before-building.md and follow the instructions before running the diagnostic. The reference defines three search modes (local_only / private / public), the defaults that pick a mode automatically, the offline fallback, and the prompt-injection boundary.

Whatever mode you used, write the result to summary.search_summary in the structured think artifact (mode, result, existing_solution). Downstream, /nano reads existing_solution and may shortcut the plan when it is covers_80_percent.

Phase 2: The Diagnostic

Question cadence: one question per message. Ask, wait for the answer, then ask the next. When a question has natural options, offer 2-4 short choices the user can pick from; an open answer is always welcome. Never batch the diagnostic into a numbered list of questions. The mode's questions still need to land before the brief is complete; the cadence changes how they arrive, not how many there are.

Apply the archetype lens to the opening question and the diagnostic emphasis (see lens definitions in think/references/archetypes.md). The archetype selects and reorders the forcing questions, it does not replace them. Cover the active mode's diagnostic set: Startup forcing questions for founder_validation and landing_experience; Builder forcing questions for cli_tooling and api_backend. The archetype→mode mapping lives in think/references/archetypes.md ("Mode interaction"). The lens decides which question opens the conversation and which risks get extra airtime.

Archetype	Primary opening question	Diagnostic emphasis
founder_validation	Who has this problem today, and what are they doing without your product?	target-user specificity, current workaround, smallest useful version, manual delivery test.
cli_tooling	What command should exist, what should it print, and what must not break?	exact command shape, I/O contract, storage format, exit codes, shell quoting, backward compatibility.
api_backend	What observable API behavior should change, and how will we prove it with a real request?	endpoint semantics, HTTP method/status, response body, backward compatibility, logging safety, readiness truthfulness.
landing_experience	Who lands here, what do they need to understand in five seconds, and what should they do next?	audience, comparison set, headline clarity, proof, CTA, mobile layout, no third-party scripts.
unknown	Use the canonical Startup Mode opening (Demand Reality).	Existing detection, no archetype-specific reordering.

Startup Mode — Six Forcing Questions

Read think/references/forcing-questions.md and cover all six: Demand Reality, Status Quo, Desperate Specificity, Starting Point, Observation & Surprise, Future-Fit. Adapt order to conversation flow. The archetype selects which one opens the diagnostic; the rest still need to land before the brief is complete.

Synthesize: What is the one sentence value proposition that survives all six questions?

Builder Mode — Engineering Forcing Questions

For internal tools, infra, and developer experience:

#	Question	What it reveals
1	Pain frequency	How often does this pain occur? Daily pain > monthly pain.
2	Current workaround	What are people doing now? If the workaround works, the tool may not be needed.
3	Blast radius	How many people/systems does this affect?
4	Reversibility	Can we undo this if it's wrong? Irreversible decisions need more thought.
5	Simplest version	What's the version you could ship today in 2 hours?
6	Composition	Does this compose with existing tools or replace them? Composition wins.

Phase 3: Ambition Check

Challenge: is the user thinking small because of habit, or because small is genuinely right? An AI agent builds a web app as fast as a bash script. If "just a CLI" when a real product would serve better, reframe upward. If CLI is genuinely right (developer audience, composes with existing tools, local-first), say so and move on.

Phase 4: Premise Challenge

Challenge the fundamental premise:

"The thing we haven't questioned is whether {{the core assumption}} is actually true."

Apply CEO cognitive patterns from think/references/cognitive-patterns.md (Inversion, Customer Obsession, 10x vs 10%, Starting Point).

Then apply the latent vs deterministic lens from think/references/latent-vs-deterministic.md. Ask: which parts of this plan rely on the model doing the right thing (latent) versus which parts are backed by a test, a hook, or a check (deterministic)? If every mitigation against Key Risk reads "remember to X" or "document Y," the plan is latent and will decay. Flag at least one risk that needs deterministic infrastructure.

Then argue the opposite: construct the strongest case this should NOT be built. If the opposite argument is stronger, say so. If the original holds, it's battle-tested.

Phase 4.5: Alternatives

Before recommending a scope mode, lay out the solution space. Present 2-3 genuinely different ways to attack the problem, each in 2-3 lines: what it is, what it trades away, what it costs to try. Make at least one a clearly smaller cut than the user's original framing. Then recommend one and say why.

Keep the bias /think is known for: when two approaches deliver similar learning, recommend the smaller one. The point of the alternatives is not neutrality, it is making the recommendation legible: the user sees what was considered and what was traded, instead of receiving a single verdict.

In Guided profile, present the approaches in plain language as "a few ways to do this" with no internal labels. The chosen approach feeds Phase 5: it becomes the scope the mode applies to. The discarded approaches become candidates for out_of_scope and land in the brief's "Alternatives considered" section and the artifact's optional alternatives_considered field.

Phase 5: Scope Mode Selection

Based on the diagnostic and the approach chosen in Phase 4.5, recommend one of four scope modes:

Mode	When to use	Behavior
Expand	Strong demand signal, clear starting point, high conviction	Dream big. What's the full vision?
Selective expand	Good idea but some risk	Hold core scope + add 1-2 high-value extras
Hold	Solid plan, no reason to change	Bulletproof the current scope
Reduce	Weak demand signal, unclear starting point, too broad	Strip to absolute essentials

Phase 6: Handoff to /nano

Before writing the summary, check whether an observational feedback block belongs in this brief. Read think/references/observational-patterns.md. If any of the four patterns (jump-to-solution, scope drift, strong pain observation, surprising synthesis) fired with specific evidence AND the active preset does not opt out, add a ## What I noticed section after the Think Summary with one to three observations. If no pattern fired cleanly or the preset skips observational feedback (e.g. eng), omit the section entirely. A missed observation is cheap; a forced one trains the user to tune the block out.

Produce a clear brief for the next phase:

## Think Summary

**Value proposition:** {{one sentence}}
**Scope mode:** {{Expand / Selective expand / Hold / Reduce}}
**Target user:** {{who specifically}}
**Starting point:** {{the smallest thing that delivers value}}
**Key risk:** {{the one thing most likely to make this fail}}
**Premise validated:** {{yes/no — and why}}

## What I noticed   (only if a pattern fired; otherwise omit)

- {{observation anchored to a specific moment, ending in a concrete next move}}
- {{optional second, cap at three}}

Interactive validation (autopilot off): walk the brief in sections. Do not drop the whole Think Summary as one blob and ask "look good?". Present it in three small passes, one per message, same cadence as the diagnostic: first what we are building (value proposition + starting point), then who it is for and the key risk, then what stays out of scope. Confirm each section before moving to the next and fold corrections in as they arrive. When the last section is confirmed, write the final Think Summary and save. Under autopilot, skip the section walk: the brief gate in Phase 6.6 is the validation.

Immediately after writing the Think Summary — before anything else, before presenting next steps — save the artifact as structured JSON that matches the canonical schema in reference/artifact-schema.md. Downstream skills (/nano, bin/sprint-journal.sh, bin/resolve.sh) read the named fields, so the prose-blob form (--from-session) is no longer acceptable for /think.

Build the JSON inline and pass it to save-artifact.sh. Required fields (the autopilot brief gate refuses to advance without them): value_proposition, scope_mode, target_user, narrowest_wedge, key_risk, premise_validated. Optional but encouraged: out_of_scope, manual_delivery_test, search_summary, alternatives_considered, design_summary, context_checkpoint. The brief gate never consults the optional fields, so a brief without alternatives is still a complete brief.

Use jq -n so the output is real JSON, not a string with embedded quotes:

# Archetype fields. Set archetype="unknown" + archetype_source="fallback"
# when no archetype was used; the brief gate does not consult these
# fields so the artifact is always backward-compatible with v1
# /think readers. example_reference is null when archetype is
# "unknown".
THINK_JSON=$(jq -n \
  --arg value_proposition "..."   \
  --arg scope_mode        "..."   \
  --arg target_user       "..."   \
  --arg narrowest_wedge   "..."   \
  --arg key_risk          "..."   \
  --argjson premise_validated true \
  --argjson out_of_scope          '[]' \
  --argjson manual_delivery_test  '{"possible": false, "steps": []}' \
  --argjson search_summary        '{"mode": "local_only", "result": "", "existing_solution": "none"}' \
  --argjson alternatives_considered '[]' \
  --arg design_summary            "" \
  --arg archetype                 "unknown" \
  --arg archetype_confidence      "low" \
  --arg archetype_source          "fallback" \
  --arg archetype_reason          "" \
  --argjson example_reference     'null' \
  --argjson context_checkpoint    '{"summary":"", "key_files":[], "decisions_made":[], "open_questions":[]}' \
  '{
     phase: "think",
     summary: {
       value_proposition: $value_proposition,
       scope_mode:        $scope_mode,
       target_user:       $target_user,
       narrowest_wedge:   $narrowest_wedge,
       key_risk:          $key_risk,
       premise_validated: $premise_validated,
       out_of_scope:      $out_of_scope,
       manual_delivery_test: $manual_delivery_test,
       search_summary:    $search_summary,
       alternatives_considered: $alternatives_considered,
       design_summary:    $design_summary,
       archetype:            $archetype,
       archetype_confidence: $archetype_confidence,
       archetype_source:     $archetype_source,
       archetype_reason:     $archetype_reason,
       example_reference:    $example_reference
     },
     context_checkpoint: $context_checkpoint
   }')

~/.claude/skills/nanostack/bin/save-artifact.sh think "$THINK_JSON"

When an archetype WAS detected or set explicitly, replace the five default values with the actual ones:

Source	archetype_source	archetype_confidence
--archetype / --type flag	explicit_flag	user_selected
User answered the one-question classifier	user_answer	user_selected
Current path matches examples/<archetype>	detected_from_files	high
Strong project-file signal	detected_from_files	high or medium
Prompt keyword score	detected_from_prompt	medium or low
session.archetype field	session	user_selected
No signal hit threshold	fallback	low

archetype_reason is one short sentence the user could read: e.g. "Current project has server.js and the prompt references an endpoint." Empty string is acceptable for the unknown/fallback case.

alternatives_considered carries the Phase 4.5 pass when it happened: one object per approach, {"approach": "string", "tradeoff": "string", "chosen": false}, with chosen: true on the one that won. design_summary is 2-4 sentences on how the chosen approach works, the same prose that lands in the brief's Design section. Leave both empty when Phase 4.5 collapsed to a single obvious approach; the gate never reads them.

example_reference is null when archetype is unknown. Otherwise it is the object documented in think/references/archetypes.md for that archetype:

{
  "name": "starter-todo|cli-notes|api-healthcheck|static-landing",
  "path": "examples/<example>",
  "why_relevant": "string"
}

This is the first thing you do after the summary. Not optional. Not "Step 2". The summary and the save are one action. After this:

• bin/sprint-journal.sh reads .summary.value_proposition / .scope_mode / .narrowest_wedge / .key_risk directly.
• bin/resolve.sh plan returns the structured summary object so /nano can pre-populate its plan with narrowest_wedge as the scope constraint and out_of_scope as the do-not-touch list.

Phase 6.5: Think Brief (shareable)

Save a clean markdown brief to .nanostack/know-how/briefs/YYYY-MM-DD-<slug>.md (slug from the value proposition). This is a human-readable version of the Think Summary the user can share with their team, open in Obsidian, or paste into a doc. Do NOT use save-artifact.sh — this is a markdown doc, not a JSON artifact.

mkdir -p .nanostack/know-how/briefs

Format and rules: see think/references/brief-template.md. Keep under 30 lines, skip sections that don't apply.

Phase 6.6: Minimum Viable Brief Gate

Before continuing to /nano (whether under autopilot or as the final user-facing handoff), validate that the brief has the required fields per reference/artifact-schema.md. The autopilot promise is "discuss the idea, approve the brief, walk away" — that is only honest when there is actually a brief to walk away from.

Read the artifact you just saved and check the required fields are populated and non-empty:

THINK_FILE=$("$REPO/bin/find-artifact.sh" think 1 2>/dev/null)
GATE_OK=$(jq -r '
  (.summary.value_proposition // "") != "" and
  (.summary.target_user        // "") != "" and
  (.summary.narrowest_wedge    // "") != "" and
  (.summary.key_risk           // "") != "" and
  ((.summary.premise_validated | type) == "boolean")
' "$THINK_FILE")

premise_validated must be a real boolean — both true ("the premise is validated") and false ("we discussed it and the premise is NOT validated yet") count as a complete answer. The earlier filter (.summary.premise_validated // null) != null was a bug: in jq, false // null evaluates to null, so an honest "no, premise not validated" was treated identically to a missing field. The fix uses the type test so true, false both pass and only null / missing / wrong-type fails.

When premise_validated == false and the gate passes, advancing to /nano is still a real product decision: the agent should call out "premise unvalidated" in the summary so the user can decide to ship a probe rather than a full sprint. The gate's job is to reject inventions, not to overrule the user's honest answer.

Brief gate does NOT require archetype. The five fields above are exhaustive. A complete brief without an archetype field, or with archetype = "unknown", must still pass the gate. Missing archetype alone never blocks autopilot. CI job think-archetype-brief-gate enforces this.

GATE_OK == "true": the brief is complete. Continue.

GATE_OK == "false": stop and ask exactly one focused question. Do not invent fields, do not paper over with vague language. Pick the most load-bearing missing field and ask about it directly. Examples:

• Missing target_user and narrowest_wedge: "No tengo suficiente para correr autopilot sin inventar. Necesito una sola cosa: ¿quién es el usuario específico y qué dolor querés resolver primero?"
• Missing key_risk: "Antes de seguir, una sola cosa: ¿qué es lo más probable que haga fallar esto?"
• Missing premise_validated: "Antes de avanzar: ¿la premisa de que esto es un problema real ya la validaste con alguien? Sí / no / no estoy seguro."

After the user answers, re-save the artifact with the missing field populated, re-run the gate, and continue. The gate runs once: a second consecutive failure returns control to the user without trying a third question.

When RUN_MODE=report_only, skip the gate entirely. The brief is saved as the report; do not pause and do not advance to /nano.

Phase 7: Next Step

If --autopilot was used (or the user said "autopilot", "run everything", "ship it end to end") AND the Brief Gate passed:

Autopilot active. Proceeding with the full sprint: /nano, build, /review, /security, /qa, /ship. I'll only stop for blocking issues or product questions I can't answer.

Then proceed directly to /nano without waiting. Set AUTOPILOT=true in your context and carry it through every subsequent skill.

If --autopilot was used but the Brief Gate failed: Stop. Ask the one question from Phase 6.6. Do not advance to /nano. Do not "decide for the user".

Otherwise, check if this is an early sprint (first or second for this project):

ls .nanostack/sessions/ 2>/dev/null | wc -l

If 0 or 1 archived sessions (new user), show the sprint guide:

Your brief is ready. Here's the full sprint:

1. /nano — I turn this into concrete steps with file names and risks
2. Build the feature
3. /review — two-pass code review (structure + adversarial edge cases)
4. /security — OWASP audit + secrets scan
5. /qa — open the app like a real user; cover the golden path and edge cases
6. /ship — PR, CI verification, sprint journal

Or say /think --autopilot next time and I run everything after you approve the brief.

If 2+ archived sessions (returning user), keep it short:

Ready for /nano. Say /nano to plan, or adjust the brief first.

Wait for the user to invoke /nano.

Telemetry finalize

Before handing control back to the user (or to /nano in autopilot), close out telemetry. Pass 1 as the third arg if the Think Summary you just wrote included a ## What I noticed observational feedback block (any pattern fired with specific evidence). Pass 0 if it did not, or if the active preset opts out (eng). The flag lets us measure how often the observational block fires in the wild without sending any of its content.

_F="$HOME/.claude/skills/nanostack/bin/lib/skill-finalize.sh"
[ -f "$_F" ] && . "$_F" think success 0   # 0 = no observational block this brief
# or, when an observational block was included:
# [ -f "$_F" ] && . "$_F" think success 1
unset _F

If the flow aborted (user interrupted, blocked on missing info, error in a phase), pass abort or error instead of success. The third arg is still optional; omit it if the run never got to the Think Summary. The finalize helper is a no-op when telemetry is disabled, stripped, or tier is off.

For retro mode (/think --retro), same rule applies at the end of the retro brief output.

Gotchas

• Don't skip the diagnostic. It prevents building the wrong thing.
• Search Before Building is mandatory. Phase 1.5 runs before the diagnostic.
• /think produces a brief, not a plan. If you're writing implementation steps, hand off to /nano.
• Calibrate intensity by mode. Founder pushes hard. Builder respects stated pain.
• "Fix this bug" doesn't need six forcing questions. Skip to the brief when the user already knows what they want.
• Always save the brief file. The markdown brief in .nanostack/know-how/briefs/ is as important as the JSON artifact. Users share briefs with their team.
• --retro is standalone. It does not start a new sprint or invoke /nano. It's a reflection, not a kickoff.