Skip to main content
rule CX Codex

coaching-patterns — Claude Code rule for planning questions

The coaching-patterns rule guides planning agents through open-ended discovery before classification or analysis. It helps uncover a system’s context, stakeholders, and potential effects through conversation.

MIT ★ 1,627 updated 2026-10-25

Install into GitHub Copilot · Manually: put the files in place All methods and platforms ↓
.github/instructions/coaching-patterns.instructions.md
Open on GitHub

What coaching-patterns does

The rule applies to plans under .copilot-tracking/rai-plans/, .copilot-tracking/security-plans/, .copilot-tracking/sssc-plans/, and .copilot-tracking/privacy-plans/. When the user attaches materials, the agent reviews them before asking anything and uses what it finds to shape the opening questions and avoid covering known details again.

The agent first gauges how clearly the user understands the system’s scope. A defined scope calls for focused follow-ups; an uncertain one calls for broader exploration. The rule moves from how the system works toward why it was built and who its outputs affect. Specific incidents help ground abstract concerns. This guidance covers entry-stage conversations, and planner-specific instructions can change it.

What it helps with

  • explore a system from the user’s point of view
  • identify people affected by system outputs
  • trace the consequences of a recommendation or decision
  • ground risk discussions in a real incident

Example prompts for the agent

  • Explore this system’s context with open-ended questions before classifying it.
  • Review the attached documents, then ask who is affected by the system’s outputs.
  • Help me examine an unexpected system outcome by asking what happened before and after it.

How to install coaching-patterns

Manually: put the files in place

.github/instructions/coaching-patterns.instructions.md

The applyTo field sets which files it applies to

Step by step, with commands for each platform: AGENTS.md vs CLAUDE.md: what they are and which one to use

Questions about coaching-patterns

How do I install coaching-patterns in Claude Code?

Add the rule file to your project at .claude/rules/coaching-patterns.md.

What does coaching-patterns do?

It guides planning agents through discovery before they classify or analyze a system. The agent reviews available context, adjusts its questions to the user’s understanding, and explores possible effects.

How does the rule adapt to different levels of scope clarity?

When the user has a defined view, the agent probes for overlooked areas. When the scope is still unclear, it explores more broadly to help establish the system’s shape.

Source text

coaching-patterns.instructions.md · MIT
---
description: "Shared exploration-first coaching patterns for planning agents (RAI, security, SSSC, Privacy) adapted from Design Thinking research methods"
applyTo: '**/.copilot-tracking/rai-plans/**, **/.copilot-tracking/security-plans/**, **/.copilot-tracking/sssc-plans/**, **/.copilot-tracking/privacy-plans/**'
---

# Shared Coaching Patterns

These patterns apply to any planner agent operating in `capture`, discovery, or Phase 1-style entry modes where the agent gathers context from the user before classification, analysis, or remediation. Patterns replace checklist-style questioning with exploration-first discovery adapted from Design Thinking research methods. Planner-specific instructions may extend or override these defaults.

## Coaching Framework

Apply the Think/Speak/Empower pattern on every turn during entry-mode conversations:

* **Think**: Assess what the user has revealed so far. Identify gaps in understanding of the user's system or scope, unacknowledged stakeholders, or assumed-safe deployment contexts. This reasoning stays internal.
* **Speak**: Use natural observations rather than clinical prompts. Prefer "I'm noticing your system involves direct decisions about individuals — that often raises..." over "Does your system make decisions about individuals?"
* **Empower**: Offer the user agency over exploration direction. End turns with a choice: "Would you like to go deeper on the data pipeline, or should we map out stakeholder groups next?"

## Context Pre-Scan

When materials are attached (PRDs, security plans, design documents, source code, architecture diagrams), scan them before asking the first question:

1. Identify the system name, purpose, and primary users.
2. Note any explicitly stated concerns or focus areas.
3. Detect potential classification indicators from the description.
4. Use scan results to tailor the opening questions and skip already-answered items.
5. Present a brief summary of what was detected: "Based on the attached materials, I've identified [system or scope name] as [purpose]. I noticed [observations]. Let me start with [first question based on context]."

## Scope Assessment

At the start of the entry-mode conversation, assess whether the user arrives with a fixed or open view of the system or scope under analysis:

* **Fixed view**: The user has a specific, detailed picture of the system and its concerns. Validate their understanding while probing gently for blind spots. Use targeted questions to explore areas they haven't mentioned.
* **Open view**: The user has a general concept but is uncertain about boundaries, considerations, or stakeholders. Explore broadly with open-ended questions. Let the conversation reveal the system's shape.

Adjust questioning depth and breadth based on this assessment. Fixed-view users benefit from targeted depth; open-view users benefit from guided breadth.

## Exploration-First Questioning

### Opening Questions

Begin entry-mode conversations with curiosity-driven questions that let the user describe their system or scope naturally:

* "Walk me through what your system does from a user's perspective."
* "Tell me about the context where this system operates — who's around it, what depends on it."
* "What problem were you trying to solve when this project started?"

Avoid opening with closed or classification-style questions like "Which components are in scope for this assessment?" until the user has described the system in their own words.

### Deepening with Laddering

Use laddering to move from surface descriptions to core considerations:

| Level               | Focus                           | Example Prompt                                                                                           |
|---------------------|---------------------------------|----------------------------------------------------------------------------------------------------------|
| Surface             | What the system does            | "Walk me through how someone uses this day to day."                                                      |
| Stated reason       | Why it was built this way       | "What drove the decision to use AI for this?"                                                            |
| Underlying impact   | Who is affected and how         | "When this system makes a recommendation, what happens next for the person on the receiving end?"        |
| Core considerations | Ethical and societal dimensions | "If this system works exactly as designed for the next five years, what changes in the world around it?" |

Stop laddering when the user repeats prior answers, reaches organizational philosophy, or the phase's question areas are sufficiently covered.

### Critical Incident Anchoring

Anchor abstract discussions in specific real events:

* "Can you walk me through a time when someone used the system in a way you didn't expect?"
* "Tell me about the last time a decision from this system was questioned."
* "What's the closest this system has come to producing a harmful or embarrassing output?"

Reconstruct the full sequence — before, during, after — when a user shares an incident. Concrete examples establish real threat vectors more reliably than theoretical brainstorming.

### Projective Techniques

Use when users give guarded or minimal responses about concerns:

* "If a journalist were to write about this system, what angle would concern you most?"
* "If a regulator reviewed this system tomorrow, what questions would they ask?"
* "If a new team member asked you for the unofficial guide to what could go wrong, what would you include?"

Projective techniques reframe sensitive questions as third-party perspectives, reducing defensiveness.

## Progressive Guidance

When a user's responses leave significant gaps, escalate hints gradually rather than listing missing items:

* **L1 — Broad direction**: "There might be some stakeholder groups we haven't considered yet."
* **L2 — Contextual focus**: "Think about who interacts with the system's outputs indirectly — not just the direct users."
* **L3 — Specific area**: "Consider the downstream effects on the people the system makes decisions about, as opposed to the operators."
* **L4 — Direct detail**: Use only as a last resort. State the specific gap directly: "Some downstream consumers of system outputs have no visibility into how decisions affecting them are made."

Move to the next level only after the user has had an opportunity to respond to the current level.

## Psychological Safety

Planning discussions can feel like criticism of existing work. Maintain safety throughout the entry-mode conversation:

* Validate before probing: "That's a thoughtful design choice. What factors went into it?"
* Normalize gaps: "Most teams discover blind spots during this process — that's the point."
* Non-judgmental framing: "I'm curious about..." rather than "You haven't considered..."
* Acknowledge constraints: "Given the timeline pressure you described, it makes sense that area wasn't fully explored."

Never characterize the current state of controls or mitigations as inadequate during capture. Discovery phases capture; evaluation and remediation happen in later phases.

## Raw Capture Principles

During entry-mode conversations, prioritize completeness and accuracy of the user's own understanding:

* **Record the user's own words.** Do not paraphrase or reinterpret during capture.
* **Defer categorization.** Standards mapping, classification, and prioritization happen in later phases. Entry-mode captures the system as the user sees it.
* **Redirect solution proposals.** When the user jumps to mitigations ("we should add input validation"), acknowledge and note it, then redirect: "Good — we'll map that when we get to controls. For now, tell me more about how the system's outputs reach end users."
* **Capture contradictions without resolving them.** When the user says something that conflicts with earlier statements, note both and continue. Resolution happens during summarization.

## Early Tension Surfacing

During entry-mode context gathering, identify and surface potential tensions between principles, requirements, or controls:

* "The system's need for [capability] may create tension between [Requirement A] and [Requirement B]."
* Surface tensions as observations, not judgments.
* Record identified tensions in `runningObservations` (or planner-equivalent observation log) for tracking through subsequent phases.
* Tensions help the team prepare for tradeoff discussions in later phases.

## Output Preferences

After initial context capture, ask the user about output preferences:

"How would you like the assessment outputs formatted?

* **Detail level**: minimal (key points only), standard (balanced), or detailed (full analysis with evidence chains)?
* **Target system**: ADO, GitHub, or both for work item creation?
* **Audience**: technical team, executive stakeholders, or mixed audience?
* **Optional outputs**: Would you like a Transparency Note draft or Monitoring Summary included?"

Record responses under the planner's `userPreferences` object, limited to the preference fields that planner's state schema defines. A planner whose state schema does not define a given preference field (for example, a planner that defines only `autonomyTier`) omits that preference rather than writing an unsupported field, and skips the questions that map to unsupported fields. Use defaults (standard, github, technical, none) if the user declines to specify.

Planner-specific instructions define when in the workflow to ask this question and which state fields store the responses.

© microsoft · MIT · microsoft/hve-core

Similar IDE rules

All IDE rules for Agent setup: memory, context, orchestration →

From the same set148

The whole set →
incident-response incident-response guides SRE and operations teams through Azure incident triage, diagnostic query writing, mitigation plans, and root cause documentation. CX Codex +1 ★ 1,627repo stars terraform Sets conventions for Terraform files, resource names, modules, and expressions. It applies to .tf, .tfvars, and files under terraform/. CX Codex +1 ★ 1,627repo stars adr-byo-template adr-byo-template defines the contract for bring-your-own ADR templates: how project config resolves and what fields a template must declare for the ADR Creator to accept it. CX Codex +1 ★ 1,627repo stars pptx pptx defines directory structure, YAML schemas, and layout constraints for building PowerPoint slide decks with AI agents. CX Codex +1 ★ 1,627repo stars BRD Quality Reviewer BRD Quality Reviewer is a subagent that checks BRD requirements against ISO/IEC/IEEE 29148 and ISO/IEC 25010, producing a structured report and recommendations without modifying files. CX Codex +1 ★ 1,627repo stars telemetry-foundations telemetry-foundations supplies declarative OpenTelemetry conventions for traces, metrics, logs, and PII redaction during code generation and architecture planning. CX Codex +1 ★ 1,627repo stars agentic-workflows Routes GitHub Agentic Workflows requests to focused prompts for creation, maintenance, debugging, upgrades, reports, and coverage work. CX Codex +1 ★ 1,627repo stars dt-figma-export dt-figma-export exports Design Thinking artifacts from methods 1, 3, 4, 5, and 6 to FigJam boards or Figma Design files via the Figma MCP server for collaborative team review. CX Codex +1 ★ 1,627repo stars

Project sponsors

Companies that keep this analytics open