steering-specs-generator

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Steering Specs Generator

Steering规范生成器

Conducts context-aware interviews to extract tacit engineering knowledge and generate agent-readable steerings. Format: Intent (Why) → Rules (What) → Practices (How) → Meta.

Supports predefined packs (8 areas) and custom topics (user-specified).

Flow overview: See flow-diagram.md for visual representation.

通过上下文感知的访谈提取隐性工程知识，生成Agent可读的Steerings。格式：Intent (Why) → Rules (What) → Practices (How) → Meta。

支持预定义包（8个领域）和自定义主题（用户指定）。

流程概览： 可视化流程请参考flow-diagram.md。

Prerequisites

前置条件

pack-reference.md — Topic areas and questions
steering-template.md — Output format
Access to an "ask user" tool and a "run subagent task" tool

pack-reference.md — 主题领域及问题
steering-template.md — 输出格式模板
可访问“询问用户”工具和“运行子Agent任务”工具

Tooling Compatibility (Claude Code ↔ Codex CLI)

工具兼容性（Claude Code ↔ Codex CLI）

This skill was originally authored for Claude Code tool names (e.g.

AskUserQuestion

Task

). To keep it portable, treat these as capabilities and map them to your runtime:

Ask user (blocking input)
- Claude Code:
```
AskUserQuestion
```
- Codex CLI:
```
request_user_input
```
- If choice options aren't supported by your tool, present choices in text and ask for an index/label.
Run subagents / parallel work
- Claude Code:
```
Task
```
  (+ its output/wait mechanism)
- Codex CLI:
```
spawn_agent
```
  +
```
wait
```
  (+ optionally
```
send_input
```
  to clarify) +
```
close_agent
```
  when done
Repo scanning / file IO
- Claude Code:
```
Read
```
  /
```
Write
```
  /
```
Glob
```
- Codex CLI:
```
exec_command
```
  for search/listing,
```
apply_patch
```
  for edits (or your runtime’s native file tools)

In the rest of this doc:

```
ASK_USER(...)
```
means "use your environment’s ask-user tool".
"Task agent" means "spawn a subagent and wait for its output".

本技能最初是为Claude Code的工具名称开发的（例如

AskUserQuestion

、

Task

）。为保证可移植性，请将这些视为功能能力，并映射到你的运行环境：

询问用户（阻塞式输入）
- Claude Code:
```
AskUserQuestion
```
- Codex CLI:
```
request_user_input
```
- 如果你的工具不支持选项选择，可将选项以文本形式展示，并要求用户输入索引/标签。
运行子Agent / 并行工作
- Claude Code:
```
Task
```
  （及其输出/等待机制）
- Codex CLI:
```
spawn_agent
```
  +
```
wait
```
  （可选
```
send_input
```
  澄清）+ 完成后调用
```
close_agent
```
仓库扫描 / 文件IO
- Claude Code:
```
Read
```
  /
```
Write
```
  /
```
Glob
```
- Codex CLI: 使用
```
exec_command
```
  进行搜索/列表，使用
```
apply_patch
```
  进行编辑（或运行环境的原生文件工具）

在本文档的其余部分：

```
ASK_USER(...)
```
表示“使用你的环境中的询问用户工具”。
“任务Agent”表示“启动子Agent并等待其输出”。

Mode Selection

模式选择

Keywords	Mode
"review steerings", "transform steerings", "fix format"	→ Review Mode (Step R)
"continue steerings", "continue session", "resume interview"	→ Interview Mode (Step 0) with session check
"steerings", "tacit knowledge", "interview", "conventions"	→ Interview Mode (Step 0)

关键词	模式
"review steerings"、"transform steerings"、"fix format"	→ 审核模式（步骤R）
"continue steerings"、"continue session"、"resume interview"	→ 访谈模式（步骤0），并检查会话
"steerings"、"tacit knowledge"、"interview"、"conventions"	→ 访谈模式（步骤0）

Interview Flow

访谈流程

Step 0: Check for Existing Sessions

步骤0：检查现有会话

Before configuring paths, check if sessions already exist in the repo:

Scan common session directories:
- ```
.sessions/
```
- ```
sessions/
```
- ```
docs/sessions/
```
If sessions found, present
```
ASK_USER(...)
```
:

yaml

questions:
  - question: "Found existing session(s). Continue or start fresh?"
    header: "Session"
    options:
      - label: "Continue {sessionId}"
        description: "Resume incomplete session ({N} of {M} packs done)"
      - label: "Start new session"
        description: "Create fresh session with new ID"

If continuing existing session:
- Set
```
sessionsPath
```
  to parent directory of found session
- Set
```
sessionId
```
  to selected session name
- Scan
```
{sessionsPath}{sessionId}/
```
  for completed pack files
- Completed pack detection: A pack is complete if:
  - File
```
{packId}.md
```
    exists AND
  - Contains
```
## Interview
```
    section with at least one
```
### Q
```
    entry
- Store
```
completedPacks[]
```
  list (pack IDs to skip)
- Read
```
explore-docs-conventions.md
```
  and
```
explore-repo-context.md
```
  paths if they exist
- Skip to Step 3 (Pack Interview Loop), filtering out completed packs
If starting new or no sessions found → Continue to Step 0a

在配置路径之前，检查仓库中是否已存在会话：

扫描常见会话目录：
- ```
.sessions/
```
- ```
sessions/
```
- ```
docs/sessions/
```
如果发现会话，调用
```
ASK_USER(...)
```
展示以下内容：

yaml

questions:
  - question: "发现现有会话。继续还是重新开始？"
    header: "会话"
    options:
      - label: "继续 {sessionId}"
        description: "恢复未完成的会话（已完成{N}/{M}个包）"
      - label: "开始新会话"
        description: "创建带有新ID的全新会话"

如果继续现有会话：
- 将
```
sessionsPath
```
  设置为找到的会话的父目录
- 将
```
sessionId
```
  设置为选中的会话名称
- 扫描
```
{sessionsPath}{sessionId}/
```
  以查找已完成的包文件
- 已完成包检测规则： 满足以下条件则视为包已完成：
  - 文件
```
{packId}.md
```
    存在，并且
  - 包含
```
## Interview
```
    章节，且至少有一个
```
### Q
```
    条目
- 存储
```
completedPacks[]
```
  列表（需要跳过的包ID）
- 如果
```
explore-docs-conventions.md
```
  和
```
explore-repo-context.md
```
  存在，则读取其路径
- 跳至步骤3（包访谈循环），过滤掉已完成的包
如果开始新会话或未发现会话 → 继续步骤0a

Step 0a: Configure Output Paths

步骤0a：配置输出路径

Ask user to confirm paths using

ASK_USER(...)

yaml

questions:
  - question: "Where should steering files be saved?"
    header: "Steerings"
    options: ["./steerings/", "docs/steerings/", ".memory-bank/steerings/", "Custom"]
  - question: "Where should session files be saved?"
    header: "Sessions"
    options: ["./sessions/", ".sessions/", "docs/sessions/", "Custom"]
  - question: "Where should action items be saved?"
    header: "Backlog"
    options: ["./backlog/", "Same as steerings parent", ".backlog/", "Custom"]

Store:

steeringsPath

sessionsPath

backlogPath

. Create directories if needed.

Defaults:

steerings/

sessions/

backlog/

调用

ASK_USER(...)

让用户确认路径：

yaml

questions:
  - question: "Steering文件应保存至何处？"
    header: "Steerings"
    options: ["./steerings/", "docs/steerings/", ".memory-bank/steerings/", "自定义"]
  - question: "会话文件应保存至何处？"
    header: "会话"
    options: ["./sessions/", ".sessions/", "docs/sessions/", "自定义"]
  - question: "行动项应保存至何处？"
    header: "待办清单"
    options: ["./backlog/", "与steerings父目录相同", ".backlog/", "自定义"]

存储：

steeringsPath

、

sessionsPath

、

backlogPath

。必要时创建目录。

默认值：

steerings/

、

sessions/

、

backlog/

Step 0b: Generate

sessionId

- short words id

步骤0b：生成

sessionId

- 短词ID

Step 1: Define Topics

步骤1：定义主题

Custom topic detected (patterns: "steerings for X", "document X conventions"):

If clear → Generate

packId

packName

packType: "custom"

customTopicDescription

If broad → Clarify with
```
ASK_USER(...)
```
(aspects, level, scope)

No custom topic → Present 8 predefined packs as multi-select:

检测到自定义主题（模式：“steerings for X”、“document X conventions”）：

如果主题明确 → 生成

packId

、

packName

、

packType: "custom"

、

customTopicDescription

如果主题宽泛 → 调用
```
ASK_USER(...)
```
澄清（方面、层级、范围）

无自定义主题 → 展示8个预定义包供多选：

Step 1a: Choose Interview Mode

步骤1a：选择访谈模式

Ask user to select interview mode using

ASK_USER(...)

yaml

questions:
  - question: "Interview mode preference?"
    header: "Mode"
    options:
      - label: "Interactive (default)"
        description: "Answer questions one-by-one with discussion"
      - label: "Fast mode"
        description: "Answer all questions at once, faster execution"

Store:

interviewMode

("interactive" or "fast")

Pack	ID
Codebase Topology & Ownership	`codebase-topology-ownership`
Architecture & Design Invariants	`architecture-design-invariants`
Business Domain Contracts	`business-domain-contracts`
Quality & Style Assurance	`quality-style-assurance`
Testing & Verification Strategy	`testing-verification-strategy`
Risk & Historical Landmines	`risk-historical-landmines`
Security, Data & Compliance	`security-data-compliance`
Delivery Lifecycle & Change Flow	`delivery-lifecycle-change-flow`

调用

ASK_USER(...)

让用户选择访谈模式：

yaml

questions:
  - question: "偏好的访谈模式？"
    header: "模式"
    options:
      - label: "交互式（默认）"
        description: "逐个回答问题并进行讨论"
      - label: "快速模式"
        description: "一次性回答所有问题，执行速度更快"

存储：

interviewMode

（值为"interactive"或"fast"）

包	ID
代码库拓扑与所有权	`codebase-topology-ownership`
架构与设计不变量	`architecture-design-invariants`
业务领域契约	`business-domain-contracts`
质量与风格保障	`quality-style-assurance`
测试与验证策略	`testing-verification-strategy`
风险与历史隐患	`risk-historical-landmines`
安全、数据与合规	`security-data-compliance`
交付生命周期与变更流程	`delivery-lifecycle-change-flow`

Step 2: Discovery (Parallel Explore)

步骤2：发现阶段（并行探索）

Run TWO Explore agents in parallel. Each writes report to

{sessionsPath}{sessionId}

and returns path.

Explore #1 - Docs & Conventions:

Analyze repository for: steering files, CONVENTIONS.md, ARCHITECTURE.md,
CLAUDE.md, README conventions, eslint/prettier/tsconfig.

OUTPUT: Write to `{sessionsPath}{sessionId}/explore-docs-conventions.md`, return path.

Explore #2 - Repo Context:

Analyze: project purpose, tech stack, directory structure, main modules, patterns.

OUTPUT: Write to `{sessionsPath}{sessionId}/explore-repo-context.md`, return path.

Capture paths:

docsConventionsReportPath

repoContextReportPath

并行运行两个探索Agent。每个Agent都会将报告写入

{sessionsPath}{sessionId}

并返回路径。

探索#1 - 文档与约定规范：

分析仓库中的以下内容：steering文件、CONVENTIONS.md、ARCHITECTURE.md、
CLAUDE.md、README约定、eslint/prettier/tsconfig配置。

输出：写入至`{sessionsPath}{sessionId}/explore-docs-conventions.md`，返回路径。

探索#2 - 仓库上下文：

分析：项目用途、技术栈、目录结构、主要模块、模式。

输出：写入至`{sessionsPath}{sessionId}/explore-repo-context.md`，返回路径。

捕获路径：

docsConventionsReportPath

、

repoContextReportPath

Step 3: Pack Interview Loop

步骤3：包访谈循环

Filter packs: If

completedPacks[]

exists (from session continuation), exclude those pack IDs from processing.

Show progress when continuing:

Continuing session: {sessionId}
✅ Completed: {completedPacks.join(', ')}
⏳ Remaining: {remainingPacks.join(', ')}

When running packs in parallel:

Launch all pack agents as background tasks
Capture all task IDs
Wait for all to complete (Claude: Task output/wait; Codex:
```
wait
```
)
Display progress as packs finish

Spawn a Task agent per pack - run all in parallel for faster execution. Claude Code: use

run_in_background: true

for each

Task

call, then wait for all to complete.

Codex CLI:

spawn_agent

for each pack, capture agent IDs, then

wait

for completion (optionally streaming progress as each finishes).

yaml

subagent_type: "general-purpose"
description: "Interview for {packName}"
prompt: |
  Conduct interview for a single pack and save results.

  ## Pack Info
  - Pack ID: {packId}
  - Pack Name: {packName}
  - Pack Type: {packType}  # "predefined" or "custom"
  - Custom Description: {customTopicDescription}  # only if custom

  ## Context Files
  - Pack Reference: pack-reference.md
  - Repo Context: {repoContextReportPath}
  - Docs & Conventions: {docsConventionsReportPath}

  ## Output
  - Path: {sessionsPath}{sessionId}/{packId}.md

  ## Instructions

  ### 1. Read Context
  Read pack-reference.md to get question themes for this pack.

  Read repoContextReportPath and docsConventionsReportPath for grounding.
  These reports contain ALL necessary findings - do NOT run additional explores.

  ### 2. Generate Questions
  Question count:
  - Predefined: 5
  - Custom (narrow): 3-4
  - Custom (medium): 5
  - Custom (broad): 6-7

  Guidelines:
  - Ground ONLY in the provided explore reports + existing docs
  - Reference actual code: "I see X in Y file..." (from reports)
  - Ask about conventions, not roadmap
  - Offer 4 options (A/B/C/D)
  - Mark one as "⭐ Recommended" at end of description

  Pattern:
  Q: I found {finding}. How should {convention question}?
  A) {Option} — {rationale}
  B) {Option} — {rationale} ⭐ Recommended
  C) {Option} — {rationale}
  D) {Option} — {rationale}

  ### 3. Conduct Interview
  If interviewMode is "fast":
    - Present all questions in a single markdown code block
    - User responds with all answers at once (e.g., "A, B, A, C, B")
  If interviewMode is "interactive":
    - Present via `ASK_USER(...)` (max 4 questions per call if your runtime supports batching)

  ### 4. Classify Responses
  For each response, classify as:
  - CONVENTION: Timeless, future-focused ("When implementing X, do Y")
  - ACTION_ITEM: Temporal, fixes current state ("Replace X", "Fix X")

  ### 5. Extract and Save Results
  Extract rules immediately (not full Q&A) and write to {sessionsPath}{sessionId}/{packId}.md:
  - CONVENTION items → "## Conventions" section
  - ACTION_ITEM items → "## Action Items" section with severity
  - Optionally preserve raw Q&A in collapsed "## Raw Interview" section

Session structure:

{sessionsPath}
└── {sessionId}/
    ├── codebase-topology-ownership.md
    ├── architecture-design-invariants.md
    ├── {custom-pack-id}.md
    └── ...

Pack file format:

markdown

undefined

过滤包： 如果存在

completedPacks[]

（来自会话续接），则排除这些包ID的处理。

续接时展示进度：

正在续接会话：{sessionId}
✅ 已完成：{completedPacks.join(', ')}
⏳ 剩余：{remainingPacks.join(', ')}

并行运行包时：

启动所有包Agent作为后台任务
捕获所有任务ID
等待所有任务完成（Claude：使用Task的输出/等待机制；Codex：使用
```
wait
```
）
当包完成时展示进度

为每个包启动一个任务Agent - 并行运行以提升执行速度。 Claude Code：为每个

Task

调用设置

run_in_background: true

，然后等待所有任务完成。

Codex CLI：为每个包调用

spawn_agent

，捕获Agent ID，然后调用

wait

等待完成（可选：每个包完成时流式展示进度）。

yaml

subagent_type: "general-purpose"
description: "针对{packName}的访谈"
prompt: |
  针对单个包进行访谈并保存结果。

  ## 包信息
  - 包ID: {packId}
  - 包名称: {packName}
  - 包类型: {packType}  # "predefined"或"custom"
  - 自定义描述: {customTopicDescription}  # 仅自定义包需要

  ## 上下文文件
  - 包参考: pack-reference.md
  - 仓库上下文: {repoContextReportPath}
  - 文档与约定规范: {docsConventionsReportPath}

  ## 输出
  - 路径: {sessionsPath}{sessionId}/{packId}.md

  ## 说明

  ### 1. 读取上下文
  读取pack-reference.md以获取此包的问题主题。

  读取repoContextReportPath和docsConventionsReportPath以获取背景信息。
  这些报告包含所有必要的发现结果 - 无需运行额外的探索任务。

  ### 2. 生成问题
  问题数量：
  - 预定义包：5个
  - 自定义（窄范围）：3-4个
  - 自定义（中等范围）：5个
  - 自定义（宽范围）：6-7个

  指导原则：
  - 仅基于提供的探索报告和现有文档生成问题
  - 引用实际代码：“我在Y文件中发现X...”（来自报告）
  - 询问约定规范，而非路线图
  - 提供4个选项（A/B/C/D）
  - 在描述末尾标记一个“⭐ 推荐”选项

  格式：
  Q: 我发现了{finding}。{约定规范问题}应如何处理？
  A) {选项} — {理由}
  B) {选项} — {理由} ⭐ 推荐
  C) {选项} — {理由}
  D) {选项} — {理由}

  ### 3. 开展访谈
  如果interviewMode为"fast"：
    - 将所有问题放在一个markdown代码块中展示
    - 用户一次性回复所有答案（例如："A, B, A, C, B"）
  如果interviewMode为"interactive"：
    - 通过`ASK_USER(...)`展示问题（如果你的运行环境支持批量处理，每次最多展示4个问题）

  ### 4. 分类回复
  对每个回复进行分类：
  - CONVENTION（约定规范）：长期有效、面向未来（“实现X时，执行Y”）
  - ACTION_ITEM（行动项）：临时、修复当前状态（“替换X”、“修复X”）

  ### 5. 提取并保存结果
  立即提取规则（而非完整的问答内容）并写入至{sessionsPath}{sessionId}/{packId}.md：
  - CONVENTION条目 → "## 约定规范"章节
  - ACTION_ITEM条目 → "## 行动项"章节，并标注优先级
  - 可选：将原始问答内容保留在折叠的"## 原始访谈"章节中

会话结构：

{sessionsPath}
└── {sessionId}/
    ├── codebase-topology-ownership.md
    ├── architecture-design-invariants.md
    ├── {custom-pack-id}.md
    └── ...

包文件格式：

markdown

undefined

{Pack Name}

{包名称}

Pack ID: {id}

包ID: {id}

Conventions

约定规范

Q1: {extracted rule}
Q2: {extracted rule}

Q1: {提取的规则}
Q2: {提取的规则}

Action Items

行动项

Q3: {action item with severity}

Q3: {带有优先级的行动项}

Raw Interview (optional, for reference)

原始访谈（可选，仅供参考）

Preserve Q&A in collapsed detail if needed for debugging.

undefined

如果调试需要，可将问答内容保留在折叠的详情区域中。

undefined

Step 4: Await Pack Interviews

步骤4：等待包访谈完成

Wait for all pack interview agents to complete. Each writes its results to

{sessionsPath}{sessionId}/{packId}.md

with classifications already included.

Note: Pack agents use existing explore reports - no additional explores are run.

等待所有包访谈Agent完成。每个Agent都会将结果写入

{sessionsPath}{sessionId}/{packId}.md

，并已包含分类信息。

注意： 包Agent使用现有的探索报告 - 不会运行额外的探索任务。

Step 5: Generate Outputs

步骤5：生成输出

Delegate to general-purpose subagent (use the strongest available model in your runtime):

yaml

subagent_type: "general-purpose"
description: "Generate steerings and action items"
prompt: |
  Generate steerings AND action items from interview sessions.

  Session directory: {sessionsPath}{sessionId}/
  (contains one .md file per pack with classifications)

  Docs report: {docsConventionsReportPath}
  Repo report: {repoContextReportPath}
  Template: steering-template.md

  Output paths: {steeringsPath}, {backlogPath}

  Instructions:
  1. Read all pack files from session directory
  2. Extract CONVENTION items → generate steering files
  3. Extract ACTION_ITEM items → generate backlog file
  4. Generate index.md for steerings

Steering filenames:

Pack ID	Filename
codebase-topology-ownership	code-ownership.md
architecture-design-invariants	architecture-invariants.md
business-domain-contracts	domain-invariants.md
quality-style-assurance	quality-and-style.md
testing-verification-strategy	testing-strategy.md
risk-historical-landmines	risk-registry.md
security-data-compliance	security-and-compliance.md
delivery-lifecycle-change-flow	delivery-lifecycle.md
{custom-pack-id}	{custom-pack-id}.md

Rule style:

✅ "When implementing X, do Y" / "Use X for Y" / "New features require X"
❌ "Proactively refactor X" / "Continue using X" / "Add X to existing code"

Action items file:

{backlogPath}steering-specs-action-items.md

Severity: 🔴 CRITICAL (data loss, security) → 🟡 HIGH → 🟢 MEDIUM → 🔵 LOW → ⏸️ DEFERRED

委托给通用子Agent（使用运行环境中可用的最强模型）：

yaml

subagent_type: "general-purpose"
description: "生成Steerings和行动项"
prompt: |
  从访谈会话中生成Steerings和行动项。

  会话目录: {sessionsPath}{sessionId}/
  （包含每个包对应的.md文件，且已包含分类信息）

  文档报告: {docsConventionsReportPath}
  仓库报告: {repoContextReportPath}
  模板: steering-template.md

  输出路径: {steeringsPath}, {backlogPath}

  说明:
  1. 读取会话目录中的所有包文件
  2. 提取CONVENTION条目 → 生成Steering文件
  3. 提取ACTION_ITEM条目 → 生成待办清单文件
  4. 为Steerings生成index.md

Steering文件名：

包ID	文件名
codebase-topology-ownership	code-ownership.md
architecture-design-invariants	architecture-invariants.md
business-domain-contracts	domain-invariants.md
quality-style-assurance	quality-and-style.md
testing-verification-strategy	testing-strategy.md
risk-historical-landmines	risk-registry.md
security-data-compliance	security-and-compliance.md
delivery-lifecycle-change-flow	delivery-lifecycle.md
{custom-pack-id}	{custom-pack-id}.md

规则风格：

✅ “实现X时，执行Y” / “将X用于Y场景” / “新功能需要X”
❌ “主动重构X” / “继续使用X” / “为现有代码添加X”

行动项文件：

{backlogPath}steering-specs-action-items.md

优先级：🔴 严重（数据丢失、安全问题）→ 🟡 高 → 🟢 中 → 🔵 低 → ⏸️ 暂缓

Step 6: Present Results

步骤6：展示结果

Generated steerings:
- {steeringsPath}*.md (N rules, M practices each)
- {steeringsPath}index.md

Action Items: {backlogPath}steering-specs-action-items.md
- 🔴 Critical: N | 🟡 High: N | 🟢 Medium: N

Session: {sessionsPath}{sessionId}/
- {packId-1}.md
- {packId-2}.md
- ...

已生成的Steerings:
- {steeringsPath}*.md（每个文件包含N条规则、M项实践）
- {steeringsPath}index.md

行动项: {backlogPath}steering-specs-action-items.md
- 🔴 严重: N | 🟡 高: N | 🟢 中: N

会话: {sessionsPath}{sessionId}/
- {packId-1}.md
- {packId-2}.md
- ...

Review Mode (Step R)

审核模式（步骤R）

Transform existing steerings to standard format.

将现有Steerings转换为标准格式。

R1: Locate Steerings

R1：定位Steerings

Auto-detect or ask:

steerings/

docs/steerings/

.steerings/

自动检测或询问用户路径：

steerings/

、

docs/steerings/

、

.steerings/

R2: Analyze with Explore

R2：通过探索进行分析

yaml

subagent_type: "Explore"
prompt: |
  Analyze steering files in {steeringsPath}:
  - Structure: Intent → Rules → Practices → Meta?
  - Rules: numbered, prescriptive, no metadata?
  - Code examples: 5-15 lines?
  - File size: <200 lines?

  Report compliant vs non-compliant files with specific issues.

yaml

subagent_type: "Explore"
prompt: |
  分析{steeringsPath}中的Steering文件：
  - 结构：是否遵循Intent → Rules → Practices → Meta？
  - 规则：是否编号、指令明确、无元数据？
  - 代码示例：是否为5-15行？
  - 文件大小：是否小于200行？

  报告符合规范和不符合规范的文件，并列出具体问题。

R3: Present Summary

R3：展示摘要

✅ Compliant: file1.md, file2.md
⚠️ Need transformation:
- file3.md: Missing Intent, verbose rules
- file4.md: Code examples too long

✅ 符合规范：file1.md、file2.md
⚠️ 需要转换：
- file3.md：缺少Intent，规则过于冗长
- file4.md：代码示例过长

R4: Ask Action

R4：询问操作选项

Options: Transform all | Transform specific | Backup and transform | Plan only | Skip

选项：转换所有 | 转换特定文件 | 备份后转换 | 仅制定计划 | 跳过

R5: Transform

R5：执行转换

Delegate to general-purpose subagent with transformation guidelines from steering-template.md.

委托给通用子Agent，使用steering-template.md中的转换指导原则。

R6: Present Results

R6：展示转换结果

Show changes per file, regenerate index.md.

展示每个文件的变更内容，重新生成index.md。

Quick Reference

快速参考

Activation keywords: steerings, tacit knowledge, interview, conventions, "steerings for X", "continue steerings"

Session continuation: Auto-detects existing sessions in

.sessions/

sessions/

docs/sessions/

. Offers to resume incomplete sessions, skipping completed packs.

8 Predefined Packs: Topology, Architecture, Domain, Quality, Testing, Risk, Security, Delivery

Output format: Intent (1 sentence) → Rules (numbered) → Practices (heading + explanation) → Meta

Files generated:

```
{steeringsPath}*.md
```
— Steering files
```
{steeringsPath}index.md
```
— Table of contents

{backlogPath}steering-specs-action-items.md

— Action items

```
{sessionsPath}{sessionId}/{packId}.md
```
— Interview responses per pack
```
{sessionsPath}explore-*.md
```
— Discovery reports

Reference files:

flow-diagram.md — Visual flow
pack-reference.md — Pack definitions and Explore prompts
steering-template.md — Output format validation

触发关键词： steerings、隐性知识、访谈、约定规范、“针对X的steerings”、“继续生成steerings”

会话续接： 自动检测

.sessions/

、

sessions/

、

docs/sessions/

中的现有会话，提供恢复未完成会话的选项，跳过已完成的包。

8个预定义包： 拓扑、架构、领域、质量、测试、风险、安全、交付

输出格式： Intent（1句话）→ Rules（编号）→ Practices（标题+说明）→ Meta

生成的文件：

```
{steeringsPath}*.md
```
— Steering文件
```
{steeringsPath}index.md
```
— 目录

{backlogPath}steering-specs-action-items.md

— 行动项

```
{sessionsPath}{sessionId}/{packId}.md
```
— 每个包的访谈回复
```
{sessionsPath}explore-*.md
```
— 发现报告

参考文件：

flow-diagram.md — 可视化流程
pack-reference.md — 包定义和探索提示
steering-template.md — 输出格式验证

steering-specs-generator

Original

Translation

Steering Specs Generator

Steering规范生成器

Prerequisites

前置条件

Tooling Compatibility (Claude Code ↔ Codex CLI)

工具兼容性（Claude Code ↔ Codex CLI）

Mode Selection

模式选择

Interview Flow

访谈流程

Step 0: Check for Existing Sessions

步骤0：检查现有会话

Step 0a: Configure Output Paths

步骤0a：配置输出路径

Step 0b: Generate sessionId - short words id

步骤0b：生成sessionId - 短词ID

Step 1: Define Topics

步骤1：定义主题

Step 1a: Choose Interview Mode

步骤1a：选择访谈模式

Step 2: Discovery (Parallel Explore)

步骤2：发现阶段（并行探索）

Step 3: Pack Interview Loop

步骤3：包访谈循环

{Pack Name}

{包名称}

Conventions

约定规范

Action Items

行动项

Raw Interview (optional, for reference)

原始访谈（可选，仅供参考）

Step 4: Await Pack Interviews

步骤4：等待包访谈完成

Step 5: Generate Outputs

步骤5：生成输出

Step 6: Present Results

步骤6：展示结果

Review Mode (Step R)

审核模式（步骤R）

R1: Locate Steerings

R1：定位Steerings

R2: Analyze with Explore

R2：通过探索进行分析

R3: Present Summary

R3：展示摘要

R4: Ask Action

R4：询问操作选项

R5: Transform

R5：执行转换

R6: Present Results

R6：展示转换结果

Quick Reference

快速参考

Step 0b: Generate
`sessionId`
- short words id

步骤0b：生成
`sessionId`
- 短词ID