feat(prompts): add context verification markers to SDD workflow prompts

Add emoji-based context verification markers (SDD1️⃣-SDD4️⃣) to all four SDD workflow prompts to detect context rot and instruction loss.

This technique, shared by Lada Kesseler at AI Native Dev Con Fall 2025, provides immediate visual feedback when critical instructions are being followed versus falling off due to context rot or inefficient compaction.

Changes:

- Add SDD1️⃣ marker to generate-spec.md

- Add SDD2️⃣ marker to generate-task-list-from-spec.md

- Add SDD3️⃣ marker to manage-tasks.md

- Add SDD4️⃣ marker to validate-spec-implementation.md

- Add research documentation explaining context rot and the verification technique

Author: ryderstorm

docs/emoji-context-verification-research.md

@@ -0,0 +1,148 @@
+# Emoji/Character Context Verification Technique - Research Report
+
+## Executive Summary
+
+The use of emojis or specific character sequences as verification markers in AI agent prompts is a practical technique for detecting when context instructions are being followed versus falling off due to context rot or inefficient compaction. This technique provides immediate visual feedback that critical instructions are being processed correctly.
+
+## Origin and Context
+
+### Context Rot: The Underlying Problem
+
+Research from Chroma and Anthropic has identified a phenomenon called **"context rot"** - the systematic degradation of AI performance as input context length increases, even when tasks remain simple. Key findings:
+
+- **Chroma Research (2024-2025)**: Demonstrated that even with long context windows (128K+ tokens), models show performance degradation as context length increases ([Context Rot: How Increasing Input Tokens Impacts LLM Performance](https://research.trychroma.com/context-rot))
+- **Anthropic Research**: Found that models struggle with "needle-in-a-haystack" tasks as context grows, even when the information is present ([Effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents))
+- **The Problem**: Context rot doesn't announce itself with errors - it creeps in silently, causing models to lose track, forget, or misrepresent key details
+
+### The Verification Technique
+
+The technique involves:
+
+1. **Adding a specific emoji or character sequence** to critical context instructions
+2. **Requiring the AI to always start responses with this marker**
+3. **Using visual verification** to immediately detect when instructions aren't being followed
+
+**Origin**: Shared by Lada Kesseler at AI Native Dev Con Fall (NYC, November 18-19, 2025) as a practical solution for detecting context rot in production AI workflows.
+
+## How It Works
+
+### Mechanism
+
+1. **Instruction Embedding**: Critical instructions include a specific emoji/character sequence requirement
+2. **Response Pattern**: AI is instructed to always begin responses with the marker
+3. **Visual Detection**: Missing marker = immediate signal that context instructions weren't processed
+4. **Context Wall Detection**: When the marker disappears, it indicates the context window limit has been reached or instructions were lost
+
+### Example Implementation
+
+```text
+**ALWAYS** start replies with STARTER_CHARACTER + space
+(default: 🍀)
+
+Stack emojis when requested, don't replace.
+```
+
+### Why It Works
+
+- **Token Efficiency**: Emojis are single tokens, adding minimal overhead
+- **Visual Distinctiveness**: Easy to spot in terminal/text output
+- **Pattern Recognition**: Models reliably follow explicit formatting instructions when they can see them
+- **Failure Detection**: Absence of marker immediately signals instruction loss
+
+## Reliability and Effectiveness
+
+### Strengths
+
+1. **Immediate Feedback**: Provides instant visual confirmation that instructions are being followed
+2. **Low Overhead**: Minimal token cost (1-2 tokens per response)
+3. **Simple Implementation**: Easy to add to existing prompts
+4. **Universal Application**: Works across different models and contexts
+5. **Non-Intrusive**: Doesn't interfere with actual content generation
+
+### Limitations
+
+1. **Not a Guarantee**: Presence of marker doesn't guarantee all instructions were followed correctly
+2. **Model Dependent**: Some models may be more or less reliable at following formatting instructions
+3. **Context Window Dependent**: Still subject to context window limitations
+4. **False Positives**: Marker might appear even if some instructions were lost (though less likely)
+
+### Reliability Factors
+
+- **High Reliability**: When marker appears consistently, instructions are likely being processed
+- **Medium Reliability**: When marker is inconsistent, may indicate partial context loss
+- **Low Reliability**: When marker disappears, strong indicator of context rot or instruction loss
+
+## Best Practices
+
+### Implementation Guidelines
+
+1. **Place Instructions Early**: Put marker requirements near the beginning of context
+2. **Use Distinctive Markers**: Choose emojis/characters that stand out visually
+3. **Stack for Multiple Steps**: Use concatenation (not replacement) for multi-step workflows
+4. **Verify Consistently**: Check for marker presence in every response
+5. **Document the Pattern**: Explain the purpose in comments/documentation
+
+### Workflow Integration
+
+For multi-step workflows (like SDD):
+
+- **Step 1**: `SDD1️⃣` - Generate Spec
+- **Step 2**: `SDD2️⃣` - Generate Task List
+- **Step 3**: `SDD3️⃣` - Manage Tasks
+- **Step 4**: `SDD4️⃣` - Validate Implementation
+
+**Concatenation Rule**: When moving through steps, stack markers: `SDD1️⃣ SDD2️⃣` indicates both Step 1 and Step 2 instructions are active.
+
+## Related Techniques
+
+### Context Engineering Strategies
+
+1. **Structured Prompting**: Using XML tags or Markdown headers to organize context
+2. **Context Compression**: Summarization and key point extraction
+3. **Dynamic Context Curation**: Selecting only relevant information
+4. **Memory Management**: Short-term and long-term memory separation
+5. **Verification Patterns**: Multiple verification techniques combined
+
+### Complementary Approaches
+
+- **Needle-in-a-Haystack Tests**: Verify information retrieval in long contexts
+- **Chain-of-Verification**: Self-questioning and fact-checking
+- **Structured Output**: Requiring specific formats for easier parsing
+- **Evidence Collection**: Proof artifacts and validation gates
+
+## Research Sources
+
+1. **Chroma Research**: ["Context Rot: How Increasing Input Tokens Impacts LLM Performance"](https://research.trychroma.com/context-rot)
+   - Key Finding: Demonstrated systematic performance degradation as context length increases, even with long context windows
+
+2. **Anthropic Engineering**: ["Effective context engineering for AI agents"](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)
+   - Key Finding: Discusses context pollution, compaction strategies, and structured note-taking for managing long contexts
+
+3. **Context Rot Research and Discussions**:
+   - ["Context Rot Is Already Here. Can We Slow It Down?"](https://aimaker.substack.com/p/context-rot-ai-long-inputs) - The AI Maker
+   - ["Context Rot: The Hidden Vulnerability in AI's Long Memory"](https://lego17440.medium.com/context-rot-the-hidden-vulnerability-in-ais-long-memory-afde1522b0c8) - Medium
+   - ["Context rot: the emerging challenge that could hold back LLM..."](https://www.understandingai.org/p/context-rot-the-emerging-challenge) - Understanding AI
+
+4. **Context Engineering Resources**:
+   - ["The New Skill in AI is Not Prompting, It's Context Engineering"](https://www.philschmid.de/context-engineering) - Philipp Schmid
+   - ["9 Context Engineering Strategies to Build Better AI Agents"](https://www.theaiautomators.com/context-engineering-strategies-to-build-better-ai-agents) - The AI Automators
+
+5. **AI Native Dev Con Fall 2025**: Lada Kesseler's presentation on practical context verification techniques
+   - **Speaker**: Lada Kesseler, Lead Software Developer at Logic20/20, Inc.
+   - **Conference**: AI Native Dev Con Fall, November 18-19, 2025, New York City
+   - **Talk**: "Emerging Patterns for Coding with Generative AI" / "Augmented Coding: Mapping the Uncharted Territory"
+   - **Background**: Lada is a seasoned practitioner of extreme programming, Test-Driven Development, and Domain-Driven Design who transforms complex legacy systems into maintainable architectures. She focuses on designing systems that last and serve their users, with deep technical expertise paired with empathy for both end users and fellow developers.
+   - **Note**: The emoji verification technique was shared as a practical solution for detecting context rot in production workflows. Lada has distilled her year of coding with generative AI into patterns that work in production environments.
+
+## Conclusion
+
+The emoji/character verification technique is a **practical, low-overhead solution** for detecting context rot and instruction loss in AI workflows. While not a perfect guarantee, it provides immediate visual feedback that critical instructions are being processed, making it an essential tool for production AI systems.
+
+**Recommendation**: Implement this technique in all critical AI workflows, especially those with:
+
+- Long context windows
+- Multi-step processes
+- Critical instructions that must be followed
+- Need for immediate failure detection
+
+**Reliability Assessment**: **High** for detection purposes, **Medium** for comprehensive instruction verification. Best used as part of a broader context engineering strategy.

prompts/generate-spec.md

@@ -12,6 +12,10 @@ meta:
 
 # Generate Specification
 
+## Context Verification Marker
+
+**ALWAYS** begin replies with this starting character sequence: `SDD1️⃣`
+
 ## You are here in the workflow
 
 We are at the **beginning** of the Spec-Driven Development Workflow. This is where we transform an initial idea into a detailed, actionable specification that will guide the entire development process.

prompts/generate-task-list-from-spec.md

@@ -12,6 +12,10 @@ meta:
 
 # Generate Task List From Spec
 
+## Context Verification Marker
+
+**ALWAYS** begin replies with this starting character sequence: `SDD2️⃣`
+
 ## You are here in the workflow
 
 You have completed the **spec creation** phase and now need to break down the spec into actionable implementation tasks. This is the critical planning step that bridges requirements to code.

prompts/manage-tasks.md

@@ -12,6 +12,10 @@ meta:
 
 # Manage Tasks
 
+## Context Verification Marker
+
+**ALWAYS** begin replies with this starting character sequence: `SDD3️⃣`
+
 ## You are here in the workflow
 
 You have completed the **task generation** phase and are now entering the **implementation** phase. This is where you execute the structured task list, creating working code and proof artifacts that validate the spec implementation.

prompts/validate-spec-implementation.md

@@ -13,6 +13,10 @@ meta:
 
 # Validate Spec Implementation
 
+## Context Verification Marker
+
+**ALWAYS** begin replies with this starting character sequence: `SDD4️⃣`
+
 ## You are here in the workflow
 
 You have completed the **implementation** phase and are now entering the **validation** phase. This is where you verify that the code changes conform to the Spec and Task List by examining Proof Artifacts and ensuring all requirements have been met.