get-shit-done-cc 1.1.2 → 1.2.0

package/get-shit-done/references/research-subagent-prompts.md

@@ -1,557 +1,451 @@
 # Research Subagent Prompts
 
 <overview>
-Prompt templates for subagents that research domain ecosystems before roadmap creation.
+Prompt templates for subagents that research implementation context before roadmap creation.
+
+**Critical understanding:** This research is NOT for human decision-making.
+This is CONTEXT INJECTION so Claude Code implements correctly.
 
 Each subagent:
-- Researches ONE category (ecosystem, architecture, pitfalls, or standards)
+- Receives a research manifest extracted from PROJECT.md
+- Researches ONLY the specific features, constraints, and questions in that manifest
+- Outputs HIGH-CONFIDENCE information only (no padding)
 - Writes directly to `.planning/research/{category}.md`
-- Uses WebSearch and Context7 for current information
-- Cross-verifies findings with authoritative sources
+- Formats output for Claude Code to consume during implementation
 
-These prompts are used by the research-project workflow when spawning Task tool subagents.
+**Quality bar:** Will this context make Claude Code generate correct, modern code?
 </overview>
 
-<ecosystem_subagent_prompt>
-## Ecosystem Research Subagent
+<stack_subagent_prompt>
+## Stack Research Subagent
 
-Use this template for spawning ecosystem research subagents:
+Use this template for spawning stack research subagents:
 
 ```
 <subagent_prompt>
 ## Objective
-Research the library/framework ecosystem for {domain} and write findings to .planning/research/ecosystem.md
 
-## Domain Context
-{Paste relevant sections from PROJECT.md describing what's being built}
+Research and document the libraries/tools needed for THIS specific project.
+Write findings to .planning/research/stack.md
 
-## Your Assignment
-File: .planning/research/ecosystem.md
-Category: ecosystem
-Purpose: Map the libraries, frameworks, and tools available for this domain
-
-## Research Questions
-Answer these questions through web research:
-1. What are the go-to libraries for this problem space?
-2. Which frameworks are actively maintained (commits in last 12 months)?
-3. What's the "standard stack" that domain experts use?
-4. What should NOT be hand-rolled because existing solutions exist?
-5. What are the version requirements and compatibility considerations?
+## Critical Context
 
-## Research Requirements
+**This research is for Claude Code, not humans.**
 
-You MUST use WebSearch and Context7 to get current information.
+You are providing context injection so Claude Code implements correctly. Claude's training data may have outdated library versions, deprecated APIs, or old patterns. Your research overrides stale knowledge with current, accurate information.
 
-For EACH library/tool discovered:
-1. Verify actively maintained (GitHub commits in last 12 months)
-2. Get current version number
-3. Understand when to use vs alternatives
-4. Find official documentation and getting started guides
-5. Note any critical dependencies or compatibility issues
+**Quality bar:** Only include information that will make Claude generate correct, modern code.
 
-**Search queries to run:**
-- "{domain} best libraries 2024 2025"
-- "{domain} framework comparison"
-- "{specific problem from PROJECT.md} library recommendation"
-- "{domain} standard stack production"
+## Research Manifest
 
-**Red flags (reject these):**
-- No updates in 12+ months
-- Deprecated or archived repositories
-- Pre-2023 recommendations without verification
+{Paste the research manifest extracted from PROJECT.md}
 
-## Output Format
+## Your Assignment
 
-Write to .planning/research/ecosystem.md using this structure:
+For EACH feature in the manifest:
+1. What library/tool should Claude use?
+2. What's the current version?
+3. What's the correct import/setup?
 
-# Ecosystem: {Domain}
+For EACH constraint in the manifest:
+1. Does the recommended library work within this constraint?
+2. Any compatibility issues?
 
-**Category:** ecosystem
-**Domain:** {domain}
-**Researched:** {today's date}
-**Confidence:** {high | medium | low}
+## Research Requirements
 
-## Research Summary
+Use WebSearch to verify CURRENT information (2024-2025).
 
-{2-3 sentences on what was found and the recommended direction}
+**INCLUDE only if:**
+- Actively maintained (commits in last 12 months)
+- High confidence this is the right choice
+- Directly relevant to a feature in the manifest
 
-## Findings
+**EXCLUDE:**
+- Low or medium confidence options
+- "Might be useful" alternatives
+- Deprecated or unmaintained libraries
+- Generic options not tied to manifest features
 
-### {Library/Framework 1}
+## Output Format
 
-{What it is and what it does}
+Write to .planning/research/stack.md:
 
-**Source:** {URL}
-**Version:** {current version}
-**Confidence:** {high | medium | low}
-**Why consider:** {Relevance to project}
-**Tradeoffs:** {Limitations or considerations}
+```markdown
+# Stack: [Project Name]
 
-### {Library/Framework 2}
+**Purpose:** Libraries and tools for Claude Code to use during implementation
+**Researched:** [date]
 
-{Same structure}
+## [Feature 1 from Scope]
 
-{... continue for each significant option ...}
+**Use:** [Library Name] v[X.Y.Z]
+**Why:** [One sentence - why this for this feature]
 
-## Recommendations
+```[language]
+// Setup / import
+[actual code]
+```
 
-### Use
+**Docs:** [URL to current documentation]
 
-- **{Library A}** - {One-line reason, specific use case}
-- **{Library B}** - {One-line reason, specific use case}
+## [Feature 2 from Scope]
 
-### Avoid
+**Use:** [Library Name] v[X.Y.Z]
+**Why:** [One sentence]
 
-- **{Library X}** - {One-line reason}
-- **Hand-rolling {Y}** - {Existing solution available}
+```[language]
+// Setup / import
+[actual code]
+```
 
-### Defer Decision
+**Docs:** [URL]
 
-- **{Topic}** - {Why more investigation needed}
+## [Continue for each feature...]
 
-## Sources
+## Constraint Compatibility
 
-| Source | Type | Confidence | Last Verified |
-|--------|------|------------|---------------|
-| {URL} | {official docs / github / blog} | {high/medium/low} | {today} |
+| Constraint | Status | Notes |
+|------------|--------|-------|
+| [constraint 1] | ✓ Compatible | [brief note] |
+| [constraint 2] | ✓ Compatible | [brief note] |
 
-## Open Questions
+## Unanswered
 
-- {Question that couldn't be resolved}
-- {Question for roadmap planning}
+- [Any features where no clear library choice exists]
+- [Any constraints that couldn't be satisfied]
+```
 
----
-*Generated by research-project subagent*
-*Category: ecosystem*
+## Quality Checklist
 
-## Quality Criteria
-- Include at least 3-5 library/framework options
-- Compare options (don't just list them)
-- Every recommendation has a specific reason
-- Verify all versions are current
-- Note what NOT to hand-roll
+Before writing output, verify:
+- [ ] Every feature from manifest has a library recommendation
+- [ ] Every library is actively maintained
+- [ ] Current versions specified (not "latest")
+- [ ] Setup code is current syntax
+- [ ] No low-confidence padding included
 </subagent_prompt>
 ```
-</ecosystem_subagent_prompt>
+</stack_subagent_prompt>
 
-<architecture_subagent_prompt>
-## Architecture Research Subagent
+<implementation_subagent_prompt>
+## Implementation Research Subagent
 
-Use this template for spawning architecture research subagents:
+Use this template for spawning implementation research subagents:
 
 ```
 <subagent_prompt>
 ## Objective
-Research architecture patterns for {domain} projects and write findings to .planning/research/architecture.md
 
-## Domain Context
-{Paste relevant sections from PROJECT.md describing what's being built}
-
-## Your Assignment
-File: .planning/research/architecture.md
-Category: architecture
-Purpose: Document standard project structure and architectural patterns
-
-## Research Questions
-Answer these questions through web research:
-1. How do experts structure projects in this domain?
-2. What component boundaries work best?
-3. What patterns prevent common problems?
-4. How does data flow in typical implementations?
-5. What directory structure do production projects use?
-
-## Research Requirements
-
-You MUST use WebSearch and Context7 to get current information.
-
-For EACH pattern discovered:
-1. Find real-world examples (GitHub repos, case studies)
-2. Understand the tradeoffs
-3. Note when it applies vs when it doesn't
-4. Find implementation guidelines
-
-**Search queries to run:**
-- "{domain} project structure best practices"
-- "{domain} architecture patterns"
-- "{specific problem from PROJECT.md} implementation patterns"
-- "{domain} component organization"
-- "{domain} example github repo structure"
-
-## Output Format
+Research and document CURRENT implementation patterns for this project's stack.
+Write findings to .planning/research/implementation.md
 
-Write to .planning/research/architecture.md using this structure:
+## Critical Context
 
-# Architecture: {Domain}
+**This research is for Claude Code, not humans.**
 
-**Category:** architecture
-**Domain:** {domain}
-**Researched:** {today's date}
-**Confidence:** {high | medium | low}
+Claude may generate outdated code patterns. Your job is to provide:
+- Current API syntax (not deprecated alternatives)
+- Working code examples (not pseudocode)
+- "Do this, not that" corrections
 
-## Research Summary
+**Quality bar:** Claude reads this file, then generates correct modern code.
 
-{2-3 sentences on recommended architectural approach}
+## Research Manifest
 
-## Findings
+{Paste the research manifest extracted from PROJECT.md}
 
-### Project Structure
-
-Recommended directory layout:
-```
-{concrete directory structure with comments}
-```
-
-**Source:** {Reference project or documentation}
-**Rationale:** {Why this structure works}
-
-### {Pattern 1 Name}
-
-**When to use:** {Specific scenarios}
-**Implementation:** {How to implement}
-**Example:** {Concrete code example if applicable}
-**Tradeoffs:** {What you give up}
-
-### {Pattern 2 Name}
-
-{Same structure}
-
-### Data Flow
-
-{How data moves through the system}
+## Your Assignment
 
-### Component Boundaries
+For the stack chosen in stack.md (or infer from manifest):
+1. What are the CURRENT API patterns?
+2. What code does Claude need to generate correctly?
+3. What deprecated patterns might Claude default to?
 
-{What should be separate vs combined}
+For Open Questions in the manifest:
+1. Research and provide direct answers
+2. If unanswerable, explain why
 
-## Recommendations
+## Research Requirements
 
-### Adopt
+Use WebSearch and Context7 for current documentation.
 
-- **{Pattern A}** - {Why it fits this project}
-- **{Structure B}** - {Why it fits this project}
+**INCLUDE:**
+- Actual code examples with current syntax
+- "Do this (current)" vs "Not this (deprecated)" comparisons
+- Version-specific patterns (as of 2024-2025)
+- Answers to Open Questions from manifest
 
-### Avoid
+**EXCLUDE:**
+- Theoretical explanations without code
+- Multiple options without recommendation
+- Old patterns from outdated tutorials
+- Generic advice not specific to this project
 
-- **{Anti-pattern X}** - {Why it fails}
-- **{Premature abstraction Y}** - {Why to defer}
+## Output Format
 
-## Sources
+Write to .planning/research/implementation.md:
 
-| Source | Type | Confidence | Last Verified |
-|--------|------|------------|---------------|
-| {URL} | {official docs / github / tutorial} | {high/medium/low} | {today} |
+```markdown
+# Implementation: [Project Name]
 
-## Open Questions
+**Purpose:** Current API patterns for Claude Code to use
+**Researched:** [date]
 
-- {Architecture decision that needs more context}
-- {Question about project-specific constraints}
+## [Feature 1] Implementation
 
----
-*Generated by research-project subagent*
-*Category: architecture*
+### Current Pattern (2025)
 
-## Quality Criteria
-- Include concrete directory structure
-- Document at least 2-3 patterns
-- Every recommendation has specific rationale
-- Include real example sources
-- Address data flow and component boundaries
-</subagent_prompt>
+```[language]
+// Correct way to do [thing]
+[actual working code]
 ```
-</architecture_subagent_prompt>
 
-<pitfalls_subagent_prompt>
-## Pitfalls Research Subagent
-
-Use this template for spawning pitfalls research subagents:
+### NOT This (Deprecated)
 
+```[language]
+// Claude may generate this - it's outdated
+[old pattern to avoid]
+// Why wrong: [brief explanation]
 ```
-<subagent_prompt>
-## Objective
-Research common mistakes and pitfalls in {domain} projects and write findings to .planning/research/pitfalls.md
 
-## Domain Context
-{Paste relevant sections from PROJECT.md describing what's being built}
+### Key API Details
 
-## Your Assignment
-File: .planning/research/pitfalls.md
-Category: pitfalls
-Purpose: Catalog what NOT to do and why
-
-## Research Questions
-Answer these questions through web research:
-1. What mistakes do beginners commonly make in this domain?
-2. What causes performance problems?
-3. What architectural choices lead to regret?
-4. What seems like a good idea but isn't?
-5. What are the debugging nightmares people warn about?
+- `methodName()` - [what it does, when to use]
+- `otherMethod()` - [what it does, when to use]
 
-## Research Requirements
-
-You MUST use WebSearch and Context7 to get current information.
-
-For EACH pitfall discovered:
-1. Find real examples (Stack Overflow, GitHub issues, blog posts)
-2. Understand the root cause
-3. Find the correct approach
-4. Note detection methods (how to know if you're doing this)
-
-**Search queries to run:**
-- "{domain} common mistakes"
-- "{domain} things I wish I knew"
-- "{domain} performance problems"
-- "{domain} debugging nightmare"
-- "{specific technology} gotchas"
-- "{domain} anti-patterns"
-
-## Output Format
-
-Write to .planning/research/pitfalls.md using this structure:
-
-# Pitfalls: {Domain}
-
-**Category:** pitfalls
-**Domain:** {domain}
-**Researched:** {today's date}
-**Confidence:** {high | medium | low}
+## [Feature 2] Implementation
 
-## Research Summary
+[Same structure]
 
-{2-3 sentences on the most critical pitfalls to avoid}
+## Open Questions Answered
 
-## Findings
+### [Question 1 from manifest]
 
-### {Pitfall 1: Descriptive Name}
+**Answer:** [Direct answer with source]
 
-**Problem:** {What people do wrong}
-**Why it happens:** {Root cause or common misconception}
-**Consequence:** {What goes wrong}
-**Detection:** {How to know if you're doing this}
-**Prevention:** {Correct approach}
+### [Question 2 from manifest]
 
-**Source:** {URL with real example}
-**Severity:** {high | medium | low}
+**Answer:** [Direct answer with source]
 
-### {Pitfall 2: Descriptive Name}
+## Decisions Validated
 
-{Same structure}
+### [Decision 1 from manifest]
 
-{... continue for each significant pitfall ...}
+**Validation:** ✓ Good choice / ⚠️ Gotcha
+**Notes:** [Any implementation considerations]
 
-## Recommendations
+## Patterns Summary
 
-### Critical Pitfalls (Must Avoid)
-
-1. **{Pitfall A}** - {One-line why it's critical}
-2. **{Pitfall B}** - {One-line why it's critical}
+| Task | Current Pattern | Deprecated Pattern |
+|------|-----------------|-------------------|
+| [task 1] | `doThisWay()` | `oldWay()` |
+| [task 2] | `async/await` | `callbacks` |
+```
 
-### Common But Recoverable
+## Quality Checklist
 
-- **{Pitfall C}** - {Can be fixed if caught early}
+Before writing output, verify:
+- [ ] Every code example is runnable (not pseudocode)
+- [ ] Deprecated patterns explicitly flagged
+- [ ] Open Questions from manifest answered
+- [ ] Decisions from manifest validated
+- [ ] No "it depends" - give clear recommendations
+</subagent_prompt>
+```
+</implementation_subagent_prompt>
 
-### Easy Wins
+<risks_subagent_prompt>
+## Risks Research Subagent
 
-- **{Prevention D}** - {Simple thing that prevents problems}
+Use this template for spawning risks research subagents:
 
-## Sources
+```
+<subagent_prompt>
+## Objective
 
-| Source | Type | Confidence | Last Verified |
-|--------|------|------------|---------------|
-| {URL} | {stack overflow / github issue / blog} | {high/medium/low} | {today} |
+Research what Claude Code might get WRONG when implementing this project.
+Write findings to .planning/research/risks.md
 
-## Open Questions
+## Critical Context
 
-- {Potential pitfall that needs more context}
-- {Question about project-specific risks}
+**This research is for Claude Code, not humans.**
 
----
-*Generated by research-project subagent*
-*Category: pitfalls*
+Claude's training data includes outdated tutorials, deprecated APIs, and bad patterns. Your job is to identify:
+- What Claude might generate incorrectly
+- Deprecated patterns to explicitly avoid
+- Common implementation mistakes in this domain
 
-## Quality Criteria
-- Include at least 5-7 pitfalls
-- Categorize by severity
-- Every pitfall has prevention/solution
-- Include real examples with sources
-- Focus on domain-specific issues (not generic coding advice)
-</subagent_prompt>
-```
-</pitfalls_subagent_prompt>
+**Quality bar:** After reading this, Claude avoids specific mistakes.
 
-<standards_subagent_prompt>
-## Standards Research Subagent
+## Research Manifest
 
-Use this template for spawning standards research subagents:
+{Paste the research manifest extracted from PROJECT.md}
 
-```
-<subagent_prompt>
-## Objective
-Research best practices and quality standards for {domain} projects and write findings to .planning/research/standards.md
+## Your Assignment
 
-## Domain Context
-{Paste relevant sections from PROJECT.md describing what's being built}
+For this project's domain and stack:
+1. What deprecated patterns might Claude default to?
+2. What common mistakes happen in this domain?
+3. What version-specific gotchas exist?
 
-## Your Assignment
-File: .planning/research/standards.md
-Category: standards
-Purpose: Document best practices, conventions, and quality expectations
-
-## Research Questions
-Answer these questions through web research:
-1. What does "production quality" mean for this domain?
-2. What testing approaches work for this type of project?
-3. What performance benchmarks matter?
-4. What accessibility/security considerations apply?
-5. What conventions do experts follow?
+For Decisions in the manifest:
+1. Any known issues with these choices?
+2. Pitfalls specific to this combination?
 
 ## Research Requirements
 
-You MUST use WebSearch and Context7 to get current information.
+Use WebSearch to find:
+- GitHub issues about common mistakes
+- Stack Overflow questions about gotchas
+- Migration guides showing old → new patterns
+- "Things I wish I knew" posts
 
-For EACH standard discovered:
-1. Find authoritative sources (official docs, style guides)
-2. Understand the rationale
-3. Find measurable criteria where possible
-4. Note enforcement tools if available
+**INCLUDE:**
+- Specific mistakes with code examples
+- Version-specific deprecations
+- Domain-specific pitfalls for this project
 
-**Search queries to run:**
-- "{domain} best practices 2024 2025"
-- "{domain} style guide"
-- "{domain} testing strategy"
-- "{domain} performance benchmarks"
-- "{domain} production checklist"
-- "{domain} code quality standards"
+**EXCLUDE:**
+- Generic coding advice
+- Low-probability edge cases
+- "Best practices" (that's not risks)
+- Risks that don't apply to this specific project
 
 ## Output Format
 
-Write to .planning/research/standards.md using this structure:
+Write to .planning/research/risks.md:
 
-# Standards: {Domain}
+```markdown
+# Risks: [Project Name]
 
-**Category:** standards
-**Domain:** {domain}
-**Researched:** {today's date}
-**Confidence:** {high | medium | low}
+**Purpose:** What Claude Code might get wrong
+**Researched:** [date]
 
-## Research Summary
+## Deprecated Patterns to Avoid
 
-{2-3 sentences on key quality standards for this project}
+### [Deprecated Thing 1]
 
-## Findings
-
-### Code Quality
-
-**Conventions:**
-- {Naming conventions}
-- {Formatting standards}
-- {Organization patterns}
-
-**Tools:** {Linters, formatters, static analysis}
-**Source:** {URL}
+**Claude might generate:**
+```[language]
+// This is outdated
+[deprecated code pattern]
+```
 
-### Testing Standards
+**Instead use:**
+```[language]
+// Current approach
+[correct code pattern]
+```
 
-**Strategy:** {How to test this type of project}
-**Coverage expectations:** {What to test, what's overkill}
-**Tools:** {Testing frameworks and utilities}
+**Why:** [Deprecated in vX.Y, removed in vX.Z, etc.]
 
-**Source:** {URL}
+### [Deprecated Thing 2]
 
-### Performance Standards
+[Same structure]
 
-**Benchmarks:** {What metrics matter}
-**Targets:** {Specific numbers if applicable}
-**Measurement:** {How to test}
+## Common Mistakes
 
-**Source:** {URL}
+### [Mistake 1: Descriptive Name]
 
-### {Domain-Specific Standard}
+**What happens:** [The incorrect approach]
+**Why it's wrong:** [Consequence]
+**Correct approach:** [What to do instead]
 
-{Standards specific to this domain}
+```[language]
+// Wrong
+[bad code]
 
-## Recommendations
+// Right
+[good code]
+```
 
-### Adopt
+### [Mistake 2]
 
-- **{Standard A}** - {Why it applies}
-- **{Convention B}** - {Why it matters}
+[Same structure]
 
-### Skip (Over-Engineering)
+## Stack-Specific Gotchas
 
-- **{Standard X}** - {Why not needed for this project}
+### [Gotcha for chosen library/framework]
 
-### Defer
+**Issue:** [What goes wrong]
+**When:** [Trigger conditions]
+**Fix:** [How to avoid/handle]
 
-- **{Standard Y}** - {Consider after MVP}
+## Decision Risks
 
-## Sources
+### [Decision 1 from manifest]
 
-| Source | Type | Confidence | Last Verified |
-|--------|------|------------|---------------|
-| {URL} | {official docs / style guide / blog} | {high/medium/low} | {today} |
+**Risk level:** Low / Medium / High
+**Specific concern:** [What could go wrong with this choice]
+**Mitigation:** [How to avoid the problem]
 
-## Open Questions
+## Critical Warnings
 
-- {Standard that depends on project scale}
-- {Question about appropriate rigor level}
+1. **[Most important thing to not mess up]**
+2. **[Second most important]**
+3. **[Third most important]**
+```
 
----
-*Generated by research-project subagent*
-*Category: standards*
+## Quality Checklist
 
-## Quality Criteria
-- Cover code quality, testing, and performance
-- Include measurable criteria where possible
-- Distinguish must-haves from nice-to-haves
-- Reference authoritative sources
-- Be realistic about project scope (not enterprise overkill)
+Before writing output, verify:
+- [ ] Every risk is specific (not generic advice)
+- [ ] Code examples show wrong vs right
+- [ ] Risks are relevant to this project's stack
+- [ ] No padding with unlikely scenarios
+- [ ] Critical warnings prioritized
 </subagent_prompt>
 ```
-</standards_subagent_prompt>
+</risks_subagent_prompt>
 
 <task_tool_usage>
 ## Using the Task Tool
 
-When spawning research subagents, use the Task tool with:
-- `subagent_type`: "general-purpose"
-- `prompt`: The filled-in template above
-- `description`: Brief description like "Research ecosystem for {domain}"
-
-**Batching strategy:**
-
-Spawn 3-4 Task calls in a SINGLE message. Wait for all to complete before next batch.
+Spawn all 3 subagents in a SINGLE message:
 
 ```
-[Message 1: Batch 1]
-Task: Research ecosystem for {domain}
-Task: Research architecture for {domain}
-[Wait for completion]
-
-[Message 2: Batch 2]
-Task: Research pitfalls for {domain}
-Task: Research standards for {domain}
-[Wait for completion]
+Task 1:
+  subagent_type: "general-purpose"
+  description: "Research stack for [project]"
+  prompt: [stack_subagent_prompt with manifest]
+
+Task 2:
+  subagent_type: "general-purpose"
+  description: "Research implementation for [project]"
+  prompt: [implementation_subagent_prompt with manifest]
+
+Task 3:
+  subagent_type: "general-purpose"
+  description: "Research risks for [project]"
+  prompt: [risks_subagent_prompt with manifest]
 ```
 
-**Batch ordering rationale:**
-- Batch 1 (ecosystem + architecture): Core understanding of what to build and how
-- Batch 2 (pitfalls + standards): Refinements that build on core understanding
-
-**After all batches complete:**
-1. Verify all 4 files exist in .planning/research/
-2. Extract key findings for summary
-3. Present next steps to user
+Wait for all to complete, then verify outputs.
 </task_tool_usage>
 
-<quality_checklist>
-## Subagent Quality Verification
+<quality_verification>
+## Post-Research Quality Check
+
+After subagents complete, verify each file:
+
+**stack.md:**
+- [ ] Every manifest feature has a library
+- [ ] Current versions specified
+- [ ] Setup code included
+- [ ] No low-confidence alternatives
+
+**implementation.md:**
+- [ ] Code examples are runnable
+- [ ] Deprecated patterns flagged
+- [ ] Open Questions answered
+- [ ] Decisions validated
 
-After subagents complete, verify:
+**risks.md:**
+- [ ] Risks specific to this project
+- [ ] Wrong vs right code shown
+- [ ] No generic advice padding
+- [ ] Critical warnings clear
 
-- [ ] All 4 files exist in .planning/research/
-- [ ] Each file has substantive content (not stub/error)
-- [ ] Recommendations are specific (not "it depends")
-- [ ] Sources are cited with confidence levels
-- [ ] Information is current (2024-2025 sources preferred)
-- [ ] Open questions are honest about gaps
-</quality_checklist>
+**If a file fails quality check:**
+Re-run that specific subagent with stricter instructions, or flag the gap for the user.
+</quality_verification>