[IMPORTANT] Use

TaskCreate

to break ALL work into small tasks BEFORE starting — including tasks for each file read. This prevents context loss from long files. For simple tasks, AI MUST ATTENTION ask user whether to skip.

External Memory: For complex or lengthy work (research, analysis, scan, review), write intermediate findings and final results to a report file in

plans/reports/

— prevents context loss and serves as deliverable.

Evidence Gate: MANDATORY IMPORTANT MUST ATTENTION — every claim, finding, and recommendation requires

file:line

proof or traced evidence with confidence percentage (>80% to act, <80% must verify first).

<!-- SYNC:critical-thinking-mindset -->

Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act. Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.

<!-- /SYNC:critical-thinking-mindset --> <!-- SYNC:ai-mistake-prevention -->

AI Mistake Prevention — Failure modes to avoid on every task:

• Check downstream references before deleting. Deleting components causes documentation and code staleness cascades. Map all referencing files before removal.
• Verify AI-generated content against actual code. AI hallucinates APIs, class names, and method signatures. Always grep to confirm existence before documenting or referencing.
• Trace full dependency chain after edits. Changing a definition misses downstream variables and consumers derived from it. Always trace the full chain.
• Trace ALL code paths when verifying correctness. Confirming code exists is not confirming it executes. Always trace early exits, error branches, and conditional skips — not just happy path.
• When debugging, ask "whose responsibility?" before fixing. Trace whether bug is in caller (wrong data) or callee (wrong handling). Fix at responsible layer — never patch symptom site.
• Assume existing values are intentional — ask WHY before changing. Before changing any constant, limit, flag, or pattern: read comments, check git blame, examine surrounding code.
• Verify ALL affected outputs, not just the first. Changes touching multiple stacks require verifying EVERY output. One green check is not all green checks.
• Holistic-first debugging — resist nearest-attention trap. When investigating any failure, list EVERY precondition first (config, env vars, DB names, endpoints, DI registrations, data preconditions), then verify each against evidence before forming any code-layer hypothesis.
• Surgical changes — apply the diff test. Bug fix: every changed line must trace directly to the bug. Don't restyle or improve adjacent code. Enhancement task: implement improvements AND announce them explicitly.
• Surface ambiguity before coding — don't pick silently. If request has multiple interpretations, present each with effort estimate and ask. Never assume all-records, file-based, or more complex path.

<!-- /SYNC:ai-mistake-prevention -->

Quick Summary

Goal: Capture raw product ideas as structured backlog artifacts with project module context.

MANDATORY IMPORTANT MUST ATTENTION Plan ToDo Task to READ the following project-specific reference doc:

• project-structure-reference.md

  -- project patterns and structure

If file not found, search for: project documentation, coding standards, architecture docs.

Workflow:

1. Gather Info — Ask about the idea, problem, value, and target users
2. Generate Artifact — Create idea file with ID (IDEA-YYMMDD-NNN) and draft status
3. Detect Module — Auto-match to project module, load feature context from docs
4. Validate — Interview user to confirm problem statement, scope, stakeholders
5. Suggest Next — Point to

   /refine

   for PBI creation

Key Rules:

• Output to

  team-artifacts/ideas/{YYMMDD}-{role}-idea-{slug}.md

Greenfield Mode

Auto-detected: If no existing codebase is found (no code directories like

src/

,

app/

,

lib/

,

server/

,

packages/

, etc., no manifest files like

package.json

/

*.sln

/

go.mod

, no populated

project-config.json

), this skill switches to greenfield mode automatically. Planning artifacts (docs/, plans/, .claude/) don't count — the project must have actual code directories with content.

When greenfield is detected:

1. Skip module auto-detection from existing project (no modules exist yet)
2. Skip "MUST ATTENTION READ project-structure-reference.md" (won't exist)
3. Focus on broader problem-space capture: market gap, competitors, differentiation
4. Output tech-agnostic problem statement (no existing tech stack to reference)
5. Enable web research for market/competitor context (WebSearch)
6. Increase AskUserQuestion frequency — capture vision, constraints, team profile, scale expectations
7. [CRITICAL] DO NOT ask about tech stack during idea capture. Tech stack is a research-driven decision that comes AFTER full business analysis (business-evaluation phase). If the user volunteers a tech stack preference, acknowledge it but still defer final decision to the tech stack research phase where it will be properly evaluated with pros/cons, market analysis, and team-fit assessment.

• Validation step is mandatory, not optional
• Auto-detect module silently; only prompt when ambiguous
• MUST ATTENTION include rough

  t_shirt_size

  (XS/S/M/L/XL) in idea artifact for early sizing

Be skeptical. Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence percentages (Idea should be more than 80%).

Idea Capture

Capture raw ideas as structured artifacts for backlog consideration.

When to Use

• User has new feature concept
• Stakeholder request needs documentation
• Quick capture without full refinement

Quick Reference

Workflow

1. Activate

   product-owner

   skill
2. Gather idea details (problem, value, scope, target users)
3. Generate artifact with ID and draft status
4. Detect related project module (dynamic discovery)
5. Load feature context from

   docs/business-features/

6. Save artifact to

   team-artifacts/ideas/

7. Validate idea (MANDATORY) - Interview user to confirm problem statement, scope, and stakeholders
8. Suggest next:

   /refine {idea-file}

Output

• Path:

  team-artifacts/ideas/{YYMMDD}-{role}-idea-{slug}.md

• ID Pattern:

  IDEA-{YYMMDD}-{NNN}

  (sequential)

Related

• Role Skill:

  product-owner

• Command:

  /idea

• Next Step:

  /refine

Template

See:

.claude/docs/team-artifacts/templates/idea-template.md

Detailed Workflow

Step 1: Gather Information

• If no title provided, ask: "What's the idea in one sentence?"
• Ask: "What problem does this solve?"
• Ask: "Who benefits from this?"
• Ask: "Any initial scope thoughts?"

Step 2: Generate Artifact

• Create idea file using template
• Generate ID:

  IDEA-{YYMMDD}-{NNN}

  (sequential)
• Set status:

  draft

Step 3: Capture Details

• Document problem statement
• List expected value
• Identify target users

Step 4: Detect Project Module

Dynamic Discovery:

1. Run:

   Glob("docs/business-features/*/README.md")

2. Extract module names from paths (e.g., ServiceB, ServiceA, SupportingServices)
3. Match idea keywords against module keywords (detect module from docs/business-features/ directory names)

Detection Approach (silent auto-detect):

• Auto-detect without showing confidence levels
• Only prompt when ambiguous or no clear match
• Multi-module: Load ALL detected modules

If module detected:

1. Read

   docs/business-features/{module}/README.md

   (first 200 lines for overview)
2. Extract feature list from Quick Navigation section
3. Add to idea frontmatter:

   • module: {detected_module}

   • related_features: [Feature1, Feature2]

If ambiguous/not detected:

• Run Glob to get current module list
• Prompt: "Which project module?" + list Glob results + "Cross-cutting/Infrastructure"

Multi-module detection:

• If 2+ modules detected, load ALL modules (no primary prompt)
• Add all to

  related_features

  list

Step 5: Load Feature Context

Once module detected:

1. Read module README overview section (~2K tokens)
2. Identify closest matching feature(s) from feature list
3. Read corresponding feature doc (3-5K tokens)
4. Extract:
   • Related entities
   • Existing business rules (BR-{MOD}-XXX)
   • Test case patterns (TC-{FEATURE}-{NNN})

Token Budget: Target 8-12K tokens total for feature context.

Step 6: Save Artifact

• Path:

  team-artifacts/ideas/{YYMMDD}-{role}-idea-{slug}.md

• Role: Infer from context or ask
• Include domain context if detected

Step 6.5: Idea Discovery Interview (MANDATORY)

Use

AskUserQuestion

to probe the idea with 3-5 structured questions. Each question MUST ATTENTION have 2-4 options with one marked "(Recommended)".

Question Categories (pick 3-5 based on idea type):

Category	Purpose	Example
Problem Clarity	Distinguish problem from solution	"What problem does this solve?" with options
User Persona	Identify primary user	"Who benefits most?" with role options
Scope	MVP vs full vision	"What's the smallest valuable version?"
Testability	Can we define done?	"How would you verify this works?"
Impact	Business value sizing	"How many users/processes does this affect?"
Constraints	Known blockers	"Any technical/business constraints?"
Scale	Expected load and growth	"How many users/transactions expected?"

Greenfield note: In greenfield mode, do NOT include tech stack questions here. Focus on business problem, users, scale, and constraints. Tech stack is evaluated in a dedicated research phase later.

Testability Question (ALWAYS include):

"How would you verify this feature works correctly?"

• Options based on domain: manual test steps, automated test criteria, metric thresholds

Document all answers in the idea artifact under

## Discovery Interview

.

Step 7: Suggest Next Step

After idea capture, suggest:

1. /refine

   — Refine into PBI (Recommended)

2. /tdd-spec

   — Jump straight to test spec creation

3. /plan

   — Start implementation planning

• Output: "Idea captured! To refine into a PBI, run:

  /refine {filename}

  "
• If domain module detected: "Module context from {module} will be used during refinement."

Validation Step (MANDATORY)

After capturing the idea, validate with user. This step is NOT optional.

Question Categories

Category	Example Question
Problem	"Is the problem statement clear and user-focused?"
Value	"What's the expected business value or user benefit?"
Scope	"Any scope boundaries to clarify now?"
Stakeholders	"Who else should review this idea?"

Process

1. Generate 2-3 questions focused on problem clarity, scope, and stakeholders
2. Use

   AskUserQuestion

   tool to interview with specific questions:
   • "Is the problem statement clear and user-focused?"
   • "Any scope boundaries to clarify now?"
   • "Who else should review this idea?"
3. Document in idea artifact under

   ## Validation Summary

4. Update idea based on answers

Validation Output Format

## Validation Summary

**Validated:** {date}

### Confirmed

- {decision}: {user choice}

### Action Items

- [ ] {follow-up if any}

Domain Context Output Format

When a project module is detected, include this section in the idea artifact:

## Domain Context (Project Features)

### Module

{module_name}

### Related Features

- {Feature1} - [docs link]
- {Feature2} - [docs link]

### Domain Entities

- **Primary:** {Entity1}, {Entity2}
- **Related:** {Entity3}

### Existing Business Rules

- BR-{MOD}-XXX: {Brief description}

UI Sketch Output Format

<!-- SYNC:ui-wireframe -->

UI Wireframe — Process visual design input (Figma URLs, screenshots, wireframes) via appropriate tool BEFORE creating wireframes. Use box-drawing ASCII characters for spatial layout. Classify every component into exactly ONE tier: Common (cross-app reusable) / Domain-Shared (cross-domain) / Page (single-page). Duplicate UI code = wrong tier. Search existing component libraries before creating new (>=80% match = reuse). Detail level varies by skill (idea=rough, story=full decomposition).

<!-- /SYNC:ui-wireframe -->

When the idea involves UI changes, include this section in the idea artifact:

## UI Sketch

### Layout

{Rough ASCII wireframe showing spatial arrangement — see UI wireframe protocol}

### Key Components

- **{Component}** — {purpose} _(tier: common | domain-shared | page/app)_
- **{Component}** — {purpose} _(tier: common | domain-shared | page/app)_

Classify components per Component Hierarchy in

UI wireframe protocol

— search existing libs before proposing new components. If backend-only idea:

## UI Sketch

→

N/A — Backend-only change. No UI affected.

Example

/idea "Dark mode toggle for settings"

Creates:

team-artifacts/ideas/260119-po-idea-dark-mode-toggle.md

/idea "Add goal progress tracking notification"

Creates with ServiceB context:

team-artifacts/ideas/260119-po-idea-goal-progress-notification.md

---

Workflow Recommendation

MANDATORY IMPORTANT MUST ATTENTION — NO EXCEPTIONS: If you are NOT already in a workflow, you MUST ATTENTION use

AskUserQuestion

to ask the user. Do NOT judge task complexity or decide this is "simple enough to skip" — the user decides whether to use a workflow, not you:

1. Activate

   idea-to-pbi

   workflow (Recommended) — idea → refine → refine-review → story → story-review → prioritize
2. Execute

   /idea

   directly — run this skill standalone

---

Next Steps

MANDATORY IMPORTANT MUST ATTENTION — NO EXCEPTIONS after completing this skill, you MUST ATTENTION use

AskUserQuestion

to present these options. Do NOT skip because the task seems "simple" or "obvious" — the user decides:

• "/refine (Recommended)" — Transform idea into actionable PBI
• "/web-research" — If idea needs market research first
• "Skip, continue manually" — user decides

Closing Reminders

MANDATORY IMPORTANT MUST ATTENTION break work into small todo tasks using

TaskCreate

BEFORE starting. MANDATORY IMPORTANT MUST ATTENTION validate decisions with user via

AskUserQuestion

— never auto-decide. MANDATORY IMPORTANT MUST ATTENTION add a final review todo task to verify work quality.

<!-- SYNC:critical-thinking-mindset:reminder -->

• MUST ATTENTION apply critical thinking — every claim needs traced proof, confidence >80% to act. Anti-hallucination: never present guess as fact. <!-- /SYNC:critical-thinking-mindset:reminder --> <!-- SYNC:ai-mistake-prevention:reminder -->
• MUST ATTENTION apply AI mistake prevention — holistic-first debugging, fix at responsible layer, surface ambiguity before coding, re-read files after compaction. <!-- /SYNC:ai-mistake-prevention:reminder -->