Overview

Create dt-method-sequencing.instructions.md — the ambient instruction file that governs how the coach manages transitions between methods, supports non-linear iteration, and tracks method progress. This addresses the "Linear vs. Iterative" tension: RPI's forward pipeline vs. DT's fluid, iterative nature.

Target File

.github/instructions/dt-method-sequencing.instructions.md

Frontmatter

---
description: 'Design Thinking method sequencing — transition rules, iteration support, and non-linear navigation'
applyTo: '**/.copilot-tracking/dt/**'
---

Required Content

Method Sequence Overview

The 9 methods span three DT spaces:

Non-Linear Iteration Support

DT is not a waterfall. Common non-linear patterns the coach must support:

• Method 8 → Method 2 loop: Testing reveals missing user data, triggering return to research
• Method 6 → Method 4 loop: Prototype feedback invalidates concept, triggering re-brainstorming
• Method 3 → Method 1 loop: Synthesis reveals scope gaps, triggering stakeholder re-engagement
• Any method → previous space: Major pivot requires revisiting earlier DT space

Transition Behavior

When a user completes a method or signals readiness to move:

1. Summarize: Brief recap of what was accomplished in the current method
2. Assess: Check whether method outputs meet minimum completion signals
3. Offer choices: Present forward, backward, or lateral movement options
4. Update state: Record method completion and current position in coaching state

Minimum Completion Signals

Each method has lightweight completion indicators (not strict gates). Examples:

• Method 1: At least one stakeholder group identified, scope boundaries articulated
• Method 2: At least one research activity conducted, raw data captured
• Method 3: Insights synthesized from research data, patterns identified

The coach observes when completion signals aren't met but empowers the user to proceed anyway — DT is about learning, not gate-keeping.

Space Boundary Transitions

Transitions between DT spaces (Problem → Solution, Solution → Implementation) are significant moments:

• Coach acknowledges the space transition explicitly
• Offers graduation choices (continue, hand off to RPI, revisit earlier methods)
• Updates coaching state's dt_space field

Integration with Coaching State

Method sequencing reads and writes:

• current_method — active method number
• current_phase — sub-method phase (planning, execution, documentation)
• dt_space — current DT space
• methods_completed — list of completed method numbers

Token Budget

Target: ~600-800 tokens (ambient tier)

How to Build This File

This is an .instructions.md file — use the prompt-builder agent (not task-implementor) for the authoring phase. The prompt-builder includes built-in Prompt Quality Criteria validation and sandbox testing specific to AI artifacts (.instructions.md, .prompt.md, .agent.md, SKILL.md).

Workflow: /task-research → /task-plan → /prompt-build → /task-review

Between each phase, use /clear to reset context, then attach the output artifact from the previous phase as input for the next.

Phase 1: Research

Gather source material for the method sequencing file.

Source Material: The upstream method sequencing, space transitions, and
iteration patterns are defined across two locations in the DT4HVE repository:

design-thinking-for-hve-capabilities/.github/chatmodes/design-thinking.chatmode.md
design-thinking-for-hve-capabilities/guidance/ (method files for transition patterns)

The chatmode defines the 9-method overview and space transition behavior. The
guidance directory contains per-method files that reveal transition patterns
between methods. If you don't have the DT4HVE repository cloned, ask a
maintainer for access.

Steps:

1. Type /clear to start a fresh conversation.
2. Attach the DT4HVE chatmode file and browse the guidance/ directory files listed above as context.
3. Copy the prompt below into chat and send.

/task-research topic="DT method sequencing for hve-core"

Research the Design Thinking method sequencing patterns for an .instructions.md
file targeting `.github/instructions/dt-method-sequencing.instructions.md`.

Use the attached DT4HVE Design Thinking Coach chatmode and guidance directory
files as primary sources. Extract and analyze:
- 9-method overview across three DT spaces (Problem, Solution, Implementation)
- Space transition behavior (Problem → Solution, Solution → Implementation)
- Non-linear iteration patterns (Method 8→2, 6→4, 3→1 loops)
- Transition behavior protocol (summarize, assess, offer choices, update state)
- Minimum completion signals per method (lightweight indicators, not strict gates)
- The "Linear vs. Iterative" tension resolution (RPI pipeline vs. DT fluidity)

Focus areas:
- How the coach facilitates transitions conversationally, not mechanically
- What triggers non-linear loops (testing reveals gaps, prototypes invalidate
  concepts, synthesis reveals scope gaps)
- How completion signals empower the user to proceed even when signals aren't met
- How coaching state fields (current_method, dt_space, methods_completed) are
  updated during transitions

The research output will feed `/task-plan` and then `/prompt-build` to author
the instructions file.

Output: DT method sequencing research

Phase 2: Plan

Plan the file structure and content organization using the research output.

Steps:

1. Type /clear to reset the conversation.
2. Attach the research document from Phase 1 (from the research phase above).
3. Copy the prompt below into chat and send.

/task-plan

Plan the implementation of
`.github/instructions/dt-method-sequencing.instructions.md` — an ambient-tier
instruction file for DT method transitions and non-linear navigation.

Use the attached research document as the primary input.

The plan should cover:
- Frontmatter structure
  (`description`, `applyTo: '**/.copilot-tracking/dt/**'`)
- Method sequence overview table (3 spaces × 3 methods each)
- Non-linear iteration support with common loop patterns
- Transition behavior protocol (summarize → assess → offer choices → update state)
- Minimum completion signals per method (lightweight, not gate-keeping)
- Space boundary transitions with graduation awareness
- Integration with coaching state fields
- Token budget target: ~600-800 tokens (ambient tier)

The implementation phase will use `/prompt-build` (not task-implementor) since
this is an AI artifact file.

Output: .copilot-tracking/plans/{date}-dt-method-sequencing-plan.md

Phase 3: Build

Author the instruction file using the prompt-builder agent. Prompt-builder handles authoring standards (frontmatter, writing style, progressive disclosure) automatically through its built-in Prompt Quality Criteria validation.

Steps:

1. Type /clear to reset the conversation.
2. Attach the plan document from Phase 2 (find it in .copilot-tracking/plans/).
3. Copy the prompt below into chat and send.

/prompt-build file=.github/instructions/dt-method-sequencing.instructions.md

Build the DT method sequencing instructions file following the attached
implementation plan.

Requirements:
- Ambient-tier instruction file loaded on all `.copilot-tracking/dt/**` paths
- Method sequence overview covering all 9 methods across 3 DT spaces
- Non-linear iteration loops documented with triggers and examples
- Transition behavior facilitates movement conversationally, not mechanically
- Minimum completion signals are lightweight — DT is about learning, not
  gate-keeping
- Space boundary transitions trigger graduation awareness with exit choices
- Integration with coaching state (current_method, dt_space, methods_completed)
- Token budget: ~600-800 tokens
- Nativize DT4HVE content for HVE Core context — avoid source-specific
  references

Output: .github/instructions/dt-method-sequencing.instructions.md

Phase 4: Review

Validate the instruction file against the plan and prompt-builder standards.

Steps:

1. Type /clear to reset the conversation.
2. Attach the plan document from Phase 2 and the new instruction file from Phase 3.
3. Copy the prompt below into chat and send.

/task-review

Review the implementation of
`.github/instructions/dt-method-sequencing.instructions.md` against the
attached plan.

Validate:
- Prompt Quality Criteria from `.github/instructions/prompt-builder.instructions.md`
- Non-linear iteration loops documented (Method 8→2, 6→4, 3→1)
- Transition behavior covers summarize → assess → offer choices → update state
- Minimum completion signals defined per method (lightweight, not gate-keeping)
- Space boundary transitions trigger graduation awareness
- Token count is within ~600-800 target (ambient tier budget)
- Frontmatter has correct `applyTo: '**/.copilot-tracking/dt/**'` glob
- No temporal markers, task IDs, or DT4HVE-specific references remain
- Writing style follows prompt-builder standards: guidance over commands,
  `*` bullets, `**bold**` for key concepts

Output: .copilot-tracking/reviews/{date}-dt-method-sequencing-review.md

After Review

The reviewer reports one of three outcomes:

• Pass — The instruction file meets all criteria. Open a PR with the new file.
• Iterate — The reviewer identified specific issues. Return to Phase 3: /clear, attach the review document, then re-run /prompt-build with the fixes noted.
• Escalate — Fundamental gaps need more research. Return to Phase 1 to investigate the identified areas.

Success Criteria

• File created at .github/instructions/dt-method-sequencing.instructions.md
• Frontmatter has applyTo: '**/.copilot-tracking/dt/**' glob
• Non-linear iteration loops documented (Method 8→2, 6→4, 3→1)
• Transition behavior covers summarize → assess → offer choices → update state
• Minimum completion signals defined per method (lightweight, not gate-keeping)
• Space boundary transitions trigger graduation awareness
• Token count within ~600-800 target
• Passes task-reviewer validation against prompt-builder standards