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

README.md

@@ -43,6 +43,7 @@ uvx --from git+https://github.com/liatrio-labs/slash-command-manager \
 - **Prompt-first workflow:** Use curated prompts to go from idea → spec → task list → implementation-ready backlog.
 - **Predictable delivery:** Every step emphasizes demoable slices, proof artifacts, and collaboration with junior developers in mind.
 - **No dependencies required:** The prompts are plain Markdown files that work with any AI assistant.
+- **Context verification:** Built-in emoji markers (SDD1️⃣-SDD4️⃣) detect when AI responses follow critical instructions, helping identify context rot issues early.
 
 ## Why Spec-Driven Development?
 
@@ -67,6 +68,14 @@ All prompts live in `prompts/` and are designed for use inside your preferred AI
 
 Each prompt writes Markdown outputs into `docs/specs/[NN]-spec-[feature-name]/` (where `[NN]` is a zero-padded 2-digit number: 01, 02, 03, etc.), giving you a lightweight backlog that is easy to review, share, and implement.
 
+### Context Verification Markers
+
+Each prompt includes a context verification marker (SDD1️⃣ for spec generation, SDD2️⃣ for task breakdown, SDD3️⃣ for task management, SDD4️⃣ for validation) that appears at the start of AI responses. These markers help detect **context rot**—a phenomenon where AI performance degrades as input context length increases, even when tasks remain simple.
+
+**Why this matters:** Context rot doesn't announce itself with errors. It creeps in silently, causing models to lose track of critical instructions. When you see the marker at the start of each response, it's an <strong>indicator</strong> that the AI is probably following the prompt's instructions. If the marker disappears, it's an immediate signal that context instructions may have been lost.
+
+**What to expect:** You'll see responses like `SDD1️⃣ I'll help you generate a specification...` or `SDD3️⃣ Let me start implementing task 1.0...`. This is normal and indicates the verification system is working. For more details, see the [research documentation](docs/emoji-context-verification-research.md).
+
 ## How does it work?
 
 The workflow is driven by Markdown prompts that function as reusable playbooks for the AI agent. Reference the prompts directly, or install them as slash commands using the [slash-command-manager](https://github.com/liatrio-labs/slash-command-manager), to keep the AI focused on structured outcomes.

docs/common-questions.html

@@ -302,6 +302,90 @@ <h3>The SDD Advantage</h3>
                 </div>
             </div>
         </section>
+
+        <!-- Context Verification Question -->
+        <section class="phases-detailed" id="why-do-ai-responses-start-with-emoji-markers">
+            <div class="container">
+                <h2>Why Do AI Responses Start with Emoji Markers (SDD1️⃣, SDD2️⃣, etc.)?</h2>
+                <p class="section-intro">You may notice that AI responses begin with emoji markers like
+                    <code>SDD1️⃣</code>, <code>SDD2️⃣</code>, <code>SDD3️⃣</code>, or <code>SDD4️⃣</code>. This is an
+                    intentional feature designed to detect a silent failure mode called <strong>context rot</strong>.
+                </p>
+
+                <div class="objection-content-grid">
+                    <div class="objection-card">
+                        <div class="objection-icon">
+                            <svg width="24" height="24" viewBox="0 0 24 24" fill="none"
+                                xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+                                <path
+                                    d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 17h-2v-2h2v2zm2.07-7.75l-.9.92C13.45 12.9 13 13.5 13 15h-2v-.5c0-1.1.45-2.1 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41 0-1.1-.9-2-2-2s-2 .9-2 2H8c0-2.21 1.79-4 4-4s4 1.79 4 4c0 .88-.36 1.68-.93 2.25z"
+                                    fill="currentColor" />
+                            </svg>
+                        </div>
+                        <h4>What Is Context Rot?</h4>
+                        <p>Research from Chroma and Anthropic demonstrates that AI performance degrades as input context
+                            length increases, even when tasks remain simple. This degradation happens silently—the AI
+                            doesn't announce errors, but gradually loses track of critical instructions.</p>
+                    </div>
+
+                    <div class="objection-card">
+                        <div class="objection-icon">
+                            <svg width="24" height="24" viewBox="0 0 24 24" fill="none"
+                                xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+                                <path d="M9 12l2 2 4-4" stroke="currentColor" stroke-width="2" stroke-linecap="round"
+                                    stroke-linejoin="round" />
+                                <path d="M21 12c0 4.97-4.03 9-9 9s-9-4.03-9-9 4.03-9 9-9 9 4.03 9 9z"
+                                    stroke="currentColor" stroke-width="2" />
+                            </svg>
+                        </div>
+                        <h4>How Verification Markers Work</h4>
+                        <p>Each prompt instructs the AI to always begin responses with its specific marker (SDD1️⃣ for
+                            spec generation, SDD2️⃣ for task breakdown, etc.). When you see the marker, it's an
+                            <strong>indicator</strong> that critical instructions are probably being followed. If the
+                            marker disappears, it's an immediate signal that context instructions may have been lost.
+                        </p>
+                    </div>
+
+                    <div class="objection-card">
+                        <div class="objection-icon">
+                            <svg width="24" height="24" viewBox="0 0 24 24" fill="none"
+                                xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+                                <path d="M13 2L3 14h9l-1 8 10-12h-9l1-8z" stroke="currentColor" stroke-width="2"
+                                    stroke-linecap="round" stroke-linejoin="round" />
+                            </svg>
+                        </div>
+                        <h4>What You Should Expect</h4>
+                        <p>Normal responses will start with the marker:
+                            <code>SDD1️⃣ I'll help you generate a specification...</code> or
+                            <code>SDD3️⃣ Let me start implementing task 1.0...</code>. This is expected behavior and
+                            indicates the verification system is working correctly. The markers add minimal overhead
+                            (1-2 tokens) while providing immediate visual feedback.
+                        </p>
+                    </div>
+                </div>
+
+                <div class="non-goals-box">
+                    <h3>Technical Background</h3>
+                    <div class="non-goals-content">
+                        <p>This verification technique was shared by Lada Kesseler at AI Native Dev Con Fall 2025 as a
+                            practical solution for detecting context rot in production AI workflows. The technique
+                            provides:</p>
+                        <ul class="non-goals-list">
+                            <li><strong>Immediate feedback:</strong> Visual confirmation that instructions are being
+                                followed</li>
+                            <li><strong>Low overhead:</strong> Minimal token cost (1-2 tokens per response)</li>
+                            <li><strong>Simple implementation:</strong> Easy to spot in terminal/text output</li>
+                            <li><strong>Failure detection:</strong> Absence of marker immediately signals instruction
+                                loss</li>
+                        </ul>
+                        <p style="margin-top: 1rem;">For detailed research and technical information, see the <a
+                                href="https://github.com/liatrio-labs/spec-driven-workflow/blob/main/docs/emoji-context-verification-research.md"
+                                target="_blank" rel="noopener noreferrer">context verification research
+                                documentation</a>.</p>
+                    </div>
+                </div>
+            </div>
+        </section>
     </main>
 
     <footer>

docs/emoji-context-verification-research.md

@@ -0,0 +1,147 @@
+# 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 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.