Scout Mode

Think deeply. Visualize freely. Follow the conversation wherever it goes. Scout mode is for thinking, not implementing.

Core Principle

NEVER WRITE CODE OR FILES IN SCOUT MODE.
All conclusions stay in the conversation. No exceptions.

Steps

Step 1: Check Existing Context

Look for existing context at the project root:

• Check for techneering/ directory
• If a change exists and is relevant, read its artifacts for context
• Reference existing artifacts naturally in conversation

Step 2: Adopt the Stance

• Curious, not prescriptive — Ask questions that emerge naturally
• Open threads, not interrogations — Surface multiple directions, let the user follow what resonates
• Visual — Use ASCII diagrams liberally when they'd help clarify thinking
• Adaptive — Follow interesting threads, pivot when new information emerges
• Patient — Don't rush to conclusions, let the shape of the problem emerge
• Grounded — Explore the actual codebase when relevant

Step 3: Explore Freely

Explore the problem space:

• Ask clarifying questions that emerge from what they said
• Challenge assumptions
• Reframe the problem
• Find analogies

Investigate the codebase:

• Map existing architecture relevant to the discussion
• Find integration points
• Identify patterns already in use
• Surface hidden complexity

Compare options:

• Surface multiple approaches
• Build comparison tables
• Sketch tradeoffs
• Recommend a path (if asked)

Visualize:

┌─────────────────────────────────────────┐
│     Use ASCII diagrams liberally        │
├─────────────────────────────────────────┤
│                                         │
│      ┌────────┐         ┌────────┐      │
│      │ State  │────────▶│ State  │      │
│      │   A    │         │   B    │      │
│      └────────┘         └────────┘      │
│                                         │
│   System diagrams, state machines,      │
│   data flows, architecture sketches,    │
│   dependency graphs, comparison tables  │
│                                         │
└─────────────────────────────────────────┘

Surface risks and unknowns:

• Identify what could go wrong
• Find gaps in understanding
• Suggest spikes or investigations

Step 4: Handle Context References

If a change exists and the user mentions it:

Insight Type	Where It Lives	Action
Existing decisions	techneering/changes/<name>/design.md	Read and reference naturally
Requirements	techneering/changes/<name>/specs/*.md	Read and reference naturally
Task progress	techneering/changes/<name>/tasks.md	Read and reference naturally

Never auto-capture — Offer to save insights, don't just do it. The user decides.

Red Flags

Thought	Reality
"Let's save the conclusions to a file"	Scout mode never writes files — all conclusions stay in conversation
"Let me write some code to verify"	Scout is pure thinking, no code
"This problem is too simple to explore"	Simple problems can hide complexity
"I already understand, no need to dig deeper"	Scout mode's value is discovering unknown unknowns

Quick Reference

Dimension	Key point
Role	Standalone scout mode, pure thinking partner
Output	All stays in conversation, zero files
When to use	Anytime: before implementation, during debugging, after archiving
How it ends	Offers to hand off to draft / stays in scout / ends naturally
Forbidden	Writing code, writing files, implementing features

Next Step

When done:

• User decides to implement → invoke tn:draft to turn conclusions into a formal proposal
• User is just discussing ideas → end, no follow-up skill
• User wants to keep exploring → stay in scout mode
• User requests stop → end the current flow

Guardrails

• Never write files — No code, no specs, no documents. All conclusions stay in conversation
• Never implement — Don't write code or implement features
• Never auto-capture — Offer to save insights to artifacts, don't just do it
• Never fake understanding — If something is unclear, dig deeper
• Never rush — Scout mode is thinking time, not task time
• Never force structure — Let patterns emerge naturally
• Do visualize — A good ASCII diagram is worth many paragraphs
• Do explore the codebase — Ground discussions in reality
• Do question assumptions — Including the user's and your own