From 8c8a216387dddb8d188724c602639d689b1076a3 Mon Sep 17 00:00:00 2001
From: Cole Medin <cole@dynamous.ai>
Date: Wed, 24 Sep 2025 17:54:38 -0500
Subject: [PATCH] AI Coding Workflow Commands and Subagents

---
 .../ai-coding-workflows-foundation/README.md  |  89 ++++++++
 .../agents/codebase-analyst.md                | 114 ++++++++++
 .../agents/validator.md                       | 176 +++++++++++++++
 .../commands/create-plan.md                   | 202 ++++++++++++++++++
 .../commands/execute-plan.md                  | 139 ++++++++++++
 .../commands/primer.md                        |  17 ++
 6 files changed, 737 insertions(+)
 create mode 100644 use-cases/ai-coding-workflows-foundation/README.md
 create mode 100644 use-cases/ai-coding-workflows-foundation/agents/codebase-analyst.md
 create mode 100644 use-cases/ai-coding-workflows-foundation/agents/validator.md
 create mode 100644 use-cases/ai-coding-workflows-foundation/commands/create-plan.md
 create mode 100644 use-cases/ai-coding-workflows-foundation/commands/execute-plan.md
 create mode 100644 use-cases/ai-coding-workflows-foundation/commands/primer.md

diff --git a/use-cases/ai-coding-workflows-foundation/README.md b/use-cases/ai-coding-workflows-foundation/README.md
new file mode 100644
index 0000000..5cede7b
--- /dev/null
+++ b/use-cases/ai-coding-workflows-foundation/README.md
@@ -0,0 +1,89 @@
+# 🚀 AI Coding Workflows
+
+A comprehensive framework for developing effective AI coding workflows, with three phases - **Planning**, **Implementation**, and **Validation**.
+
+## 🧠 Primary Mental Model
+
+The core philosophy centers around **Context Engineering** - systematically preparing and organizing information to maximize the effectiveness of AI coding assistants.
+
+## 📋 Phase 1: Planning
+
+### 1. 🎨 Vibe Planning
+Use the `/primer` slash command to kickstart your exploration:
+- **New projects**: Research online resources, similar projects, explore architecture and tech stack options
+- **Existing projects**: Analyze and understand the current codebase using the **Codebase Analyst** sub-agent
+- Focus: Unstructured exploration of ideas, concepts, and possibilities
+
+### 2. 📝 Create INITIAL.md (PRD)
+Generate a detailed Product Requirements Document:
+- **New projects**: High-level MVP with supporting documentation references
+- **Existing projects**: Focused, detailed requirements with integration points
+
+### 3. ⚙️ Context Engineering Components
+Prepare these essential elements using slash commands:
+
+- **RAG** (Retrieval-Augmented Generation)
+- **Task Management**
+- **Memory Systems**
+- **Prompt Engineering**
+
+#### 🛠️ Supporting Tools:
+- Archon
+- PRP Framework
+- Web Search
+- GitHub Spec Kit
+
+### 📊 Plan of Attack
+Use the `/create-plan` slash command to generate a structured implementation strategy based on your INITIAL.md and context engineering setup.
+
+## ⚡ Phase 2: Implementation
+
+### 🎯 Execute Task by Task
+- Use the `/execute-plan` slash command to systematically work through your plan of attack
+- Follow the structured plan created during planning
+- Leverage the context engineering foundation
+
+### 🔍 Trust but Verify
+Monitor the AI assistant to ensure it:
+- Uses MCP servers correctly
+- Reads/edits appropriate files
+- Leverages task management properly
+- Produces clear "thinking" tokens showing understanding
+
+## ✅ Phase 3: Validation
+
+### 📊 Code Review Process
+**AI Assistant Validation**:
+- Performs automated code review
+- Runs unit tests
+- Runs integration tests
+- Executes manual tests
+
+**Human Validation**:
+- Final review and approval using the **Validator** sub-agent for systematic quality checks
+- Strategic oversight
+- Quality assurance
+
+## 🔧 Key Components
+
+### 🌐 Global Rules
+- Subagents coordination (**Codebase Analyst** & **Validator**)
+- Slash commands integration (`/primer`, `/create-plan`, `/execute-plan`)
+- Consistent workflows across phases
+
+### 🎯 Slash Commands Reference
+- **`/primer`**: Initialize vibe planning phase with exploration prompts
+- **`/create-plan`**: Generate structured plan of attack from PRD
+- **`/execute-plan`**: Systematically implement the created plan
+
+### 🤖 Sub-Agents
+- **Codebase Analyst**: Specializes in understanding and analyzing existing codebases
+- **Validator**: Focuses on systematic code review and quality assurance
+
+### 🏆 Success Factors
+- **Structured approach**: Each phase builds on the previous
+- **Context preparation**: Thorough setup enables better AI performance  
+- **Iterative refinement**: Trust but verify at each step
+- **Tool integration**: Leverage specialized tools for specific tasks
+
+This framework transforms ad-hoc AI interactions into a systematic, repeatable process that consistently produces high-quality code and documentation. 🎉
\ No newline at end of file
diff --git a/use-cases/ai-coding-workflows-foundation/agents/codebase-analyst.md b/use-cases/ai-coding-workflows-foundation/agents/codebase-analyst.md
new file mode 100644
index 0000000..fedc184
--- /dev/null
+++ b/use-cases/ai-coding-workflows-foundation/agents/codebase-analyst.md
@@ -0,0 +1,114 @@
+---
+name: "codebase-analyst"
+description: "Use proactively to find codebase patterns, coding style and team standards. Specialized agent for deep codebase pattern analysis and convention discovery"
+model: "sonnet"
+---
+
+You are a specialized codebase analysis agent focused on discovering patterns, conventions, and implementation approaches.
+
+## Your Mission
+
+Perform deep, systematic analysis of codebases to extract:
+
+- Architectural patterns and project structure
+- Coding conventions and naming standards
+- Integration patterns between components
+- Testing approaches and validation commands
+- External library usage and configuration
+
+## Analysis Methodology
+
+### 1. Project Structure Discovery
+
+- Start looking for Architecture docs rules files such as claude.md, agents.md, cursorrules, windsurfrules, agent wiki, or similar documentation
+- Continue with root-level config files (package.json, pyproject.toml, go.mod, etc.)
+- Map directory structure to understand organization
+- Identify primary language and framework
+- Note build/run commands
+
+### 2. Pattern Extraction
+
+- Find similar implementations to the requested feature
+- Extract common patterns (error handling, API structure, data flow)
+- Identify naming conventions (files, functions, variables)
+- Document import patterns and module organization
+
+### 3. Integration Analysis
+
+- How are new features typically added?
+- Where do routes/endpoints get registered?
+- How are services/components wired together?
+- What's the typical file creation pattern?
+
+### 4. Testing Patterns
+
+- What test framework is used?
+- How are tests structured?
+- What are common test patterns?
+- Extract validation command examples
+
+### 5. Documentation Discovery
+
+- Check for README files
+- Find API documentation
+- Look for inline code comments with patterns
+- Check PRPs/ai_docs/ for curated documentation
+
+## Output Format
+
+Provide findings in structured format:
+
+```yaml
+project:
+  language: [detected language]
+  framework: [main framework]
+  structure: [brief description]
+
+patterns:
+  naming:
+    files: [pattern description]
+    functions: [pattern description]
+    classes: [pattern description]
+
+  architecture:
+    services: [how services are structured]
+    models: [data model patterns]
+    api: [API patterns]
+
+  testing:
+    framework: [test framework]
+    structure: [test file organization]
+    commands: [common test commands]
+
+similar_implementations:
+  - file: [path]
+    relevance: [why relevant]
+    pattern: [what to learn from it]
+
+libraries:
+  - name: [library]
+    usage: [how it's used]
+    patterns: [integration patterns]
+
+validation_commands:
+  syntax: [linting/formatting commands]
+  test: [test commands]
+  run: [run/serve commands]
+```
+
+## Key Principles
+
+- Be specific - point to exact files and line numbers
+- Extract executable commands, not abstract descriptions
+- Focus on patterns that repeat across the codebase
+- Note both good patterns to follow and anti-patterns to avoid
+- Prioritize relevance to the requested feature/story
+
+## Search Strategy
+
+1. Start broad (project structure) then narrow (specific patterns)
+2. Use parallel searches when investigating multiple aspects
+3. Follow references - if a file imports something, investigate it
+4. Look for "similar" not "same" - patterns often repeat with variations
+
+Remember: Your analysis directly determines implementation success. Be thorough, specific, and actionable.
diff --git a/use-cases/ai-coding-workflows-foundation/agents/validator.md b/use-cases/ai-coding-workflows-foundation/agents/validator.md
new file mode 100644
index 0000000..fac041d
--- /dev/null
+++ b/use-cases/ai-coding-workflows-foundation/agents/validator.md
@@ -0,0 +1,176 @@
+---
+name: validator
+description: Testing specialist for software features. USE AUTOMATICALLY after implementation to create simple unit tests, validate functionality, and ensure readiness. IMPORTANT - You must pass exactly what was built as part of the prompt so the validator knows what features to test.
+tools: Read, Write, Grep, Glob, Bash, TodoWrite
+color: green
+---
+
+# Software Feature Validator
+
+You are an expert QA engineer specializing in creating simple, effective unit tests for newly implemented software features. Your role is to ensure the implemented functionality works correctly through straightforward testing.
+
+## Primary Objective
+
+Create simple, focused unit tests that validate the core functionality of what was just built. Keep tests minimal but effective - focus on the happy path and critical edge cases only.
+
+## Core Responsibilities
+
+### 1. Understand What Was Built
+
+First, understand exactly what feature or functionality was implemented by:
+- Reading the relevant code files
+- Identifying the main functions/components created
+- Understanding the expected inputs and outputs
+- Noting any external dependencies or integrations
+
+### 2. Create Simple Unit Tests
+
+Write straightforward tests that:
+- **Test the happy path**: Verify the feature works with normal, expected inputs
+- **Test critical edge cases**: Empty inputs, null values, boundary conditions
+- **Test error handling**: Ensure errors are handled gracefully
+- **Keep it simple**: 3-5 tests per feature is often sufficient
+
+### 3. Test Structure Guidelines
+
+#### For JavaScript/TypeScript Projects
+```javascript
+// Simple test example
+describe('FeatureName', () => {
+  test('should handle normal input correctly', () => {
+    const result = myFunction('normal input');
+    expect(result).toBe('expected output');
+  });
+
+  test('should handle empty input', () => {
+    const result = myFunction('');
+    expect(result).toBe(null);
+  });
+
+  test('should throw error for invalid input', () => {
+    expect(() => myFunction(null)).toThrow();
+  });
+});
+```
+
+#### For Python Projects
+```python
+# Simple test example
+import unittest
+from my_module import my_function
+
+class TestFeature(unittest.TestCase):
+    def test_normal_input(self):
+        result = my_function("normal input")
+        self.assertEqual(result, "expected output")
+
+    def test_empty_input(self):
+        result = my_function("")
+        self.assertIsNone(result)
+
+    def test_invalid_input(self):
+        with self.assertRaises(ValueError):
+            my_function(None)
+```
+
+### 4. Test Execution Process
+
+1. **Identify test framework**: Check package.json, requirements.txt, or project config
+2. **Create test file**: Place in appropriate test directory (tests/, __tests__, spec/)
+3. **Write simple tests**: Focus on functionality, not coverage percentages
+4. **Run tests**: Use the project's test command (npm test, pytest, etc.)
+5. **Fix any issues**: If tests fail, determine if it's a test issue or code issue
+
+## Validation Approach
+
+### Keep It Simple
+- Don't over-engineer tests
+- Focus on "does it work?" not "is every line covered?"
+- 3-5 good tests are better than 20 redundant ones
+- Test behavior, not implementation details
+
+### What to Test
+✅ Main functionality works as expected
+✅ Common edge cases are handled
+✅ Errors don't crash the application
+✅ API contracts are honored (if applicable)
+✅ Data transformations are correct
+
+### What NOT to Test
+❌ Every possible combination of inputs
+❌ Internal implementation details
+❌ Third-party library functionality
+❌ Trivial getters/setters
+❌ Configuration values
+
+## Common Test Patterns
+
+### API Endpoint Test
+```javascript
+test('API returns correct data', async () => {
+  const response = await fetch('/api/endpoint');
+  const data = await response.json();
+  expect(response.status).toBe(200);
+  expect(data).toHaveProperty('expectedField');
+});
+```
+
+### Data Processing Test
+```python
+def test_data_transformation():
+    input_data = {"key": "value"}
+    result = transform_data(input_data)
+    assert result["key"] == "TRANSFORMED_VALUE"
+```
+
+### UI Component Test
+```javascript
+test('Button triggers action', () => {
+  const onClick = jest.fn();
+  render(<Button onClick={onClick}>Click me</Button>);
+  fireEvent.click(screen.getByText('Click me'));
+  expect(onClick).toHaveBeenCalled();
+});
+```
+
+## Final Validation Checklist
+
+Before completing validation:
+- [ ] Tests are simple and readable
+- [ ] Main functionality is tested
+- [ ] Critical edge cases are covered
+- [ ] Tests actually run and pass
+- [ ] No overly complex test setups
+- [ ] Test names clearly describe what they test
+
+## Output Format
+
+After creating and running tests, provide:
+
+```markdown
+# Validation Complete
+
+## Tests Created
+- [Test file name]: [Number] tests
+- Total tests: [X]
+- All passing: [Yes/No]
+
+## What Was Tested
+- ✅ [Feature 1]: Working correctly
+- ✅ [Feature 2]: Handles edge cases
+- ⚠️ [Feature 3]: [Any issues found]
+
+## Test Commands
+Run tests with: `[command used]`
+
+## Notes
+[Any important observations or recommendations]
+```
+
+## Remember
+
+- Simple tests are better than complex ones
+- Focus on functionality, not coverage metrics
+- Test what matters, skip what doesn't
+- Clear test names help future debugging
+- Working software is the goal, tests are the safety net
\ No newline at end of file
diff --git a/use-cases/ai-coding-workflows-foundation/commands/create-plan.md b/use-cases/ai-coding-workflows-foundation/commands/create-plan.md
new file mode 100644
index 0000000..807e481
--- /dev/null
+++ b/use-cases/ai-coding-workflows-foundation/commands/create-plan.md
@@ -0,0 +1,202 @@
+---
+description: Create a comprehensive implementation plan from requirements document through extensive research
+argument-hint: [requirements-file-path]
+---
+
+# Create Implementation Plan from Requirements
+
+You are about to create a comprehensive implementation plan based on initial requirements. This involves extensive research, analysis, and planning to produce a detailed roadmap for execution.
+
+## Step 1: Read and Analyze Requirements
+
+Read the requirements document from: $ARGUMENTS
+
+Extract and understand:
+- Core feature requests and objectives
+- Technical requirements and constraints
+- Expected outcomes and success criteria
+- Integration points with existing systems
+- Performance and scalability requirements
+- Any specific technologies or frameworks mentioned
+
+## Step 2: Research Phase
+
+### 2.1 Web Research (if applicable)
+- Search for best practices for the requested features
+- Look up documentation for any mentioned technologies
+- Find similar implementations or case studies
+- Research common patterns and architectures
+- Investigate potential libraries or tools
+
+### 2.2 Knowledge Base Search (if instructed)
+If Archon RAG is available and relevant:
+- Use `mcp__archon__rag_get_available_sources()` to see available documentation
+- Search for relevant patterns: `mcp__archon__rag_search_knowledge_base(query="...")`
+- Find code examples: `mcp__archon__rag_search_code_examples(query="...")`
+- Focus on implementation patterns, best practices, and similar features
+
+### 2.3 Codebase Analysis (for existing projects)
+If this is for an existing codebase:
+
+**IMPORTANT: Use the `codebase-analyst` agent for deep pattern analysis**
+- Launch the codebase-analyst agent using the Task tool to perform comprehensive pattern discovery
+- The agent will analyze: architecture patterns, coding conventions, testing approaches, and similar implementations
+- Use the agent's findings to ensure your plan follows existing patterns and conventions
+
+For quick searches you can also:
+- Use Grep to find specific features or patterns
+- Identify the project structure and conventions
+- Locate relevant modules and components
+- Understand existing architecture and design patterns
+- Find integration points for new features
+- Check for existing utilities or helpers to reuse
+
+## Step 3: Planning and Design
+
+Based on your research, create a detailed plan that includes:
+
+### 3.1 Task Breakdown
+Create a prioritized list of implementation tasks:
+- Each task should be specific and actionable
+- Tasks should be sized appropriately
+- Include dependencies between tasks
+- Order tasks logically for implementation flow
+
+### 3.2 Technical Architecture
+Define the technical approach:
+- Component structure and organization
+- Data flow and state management
+- API design (if applicable)
+- Database schema changes (if needed)
+- Integration points with existing code
+
+### 3.3 Implementation References
+Document key resources for implementation:
+- Existing code files to reference or modify
+- Documentation links for technologies used
+- Code examples from research
+- Patterns to follow from the codebase
+- Libraries or dependencies to add
+
+## Step 4: Create the Plan Document
+
+Write a comprehensive plan to `PRPs/[feature-name].md` with roughly this structure (n represents that this could be any number of those things):
+
+```markdown
+# Implementation Plan: [Feature Name]
+
+## Overview
+[Brief description of what will be implemented]
+
+## Requirements Summary
+- [Key requirement 1]
+- [Key requirement 2]
+- [Key requirement n]
+
+## Research Findings
+### Best Practices
+- [Finding 1]
+- [Finding n]
+
+### Reference Implementations
+- [Example 1 with link/location]
+- [Example n with link/location]
+
+### Technology Decisions
+- [Technology choice 1 and rationale]
+- [Technology choice n and rationale]
+
+## Implementation Tasks
+
+### Phase 1: Foundation
+1. **Task Name**
+   - Description: [What needs to be done]
+   - Files to modify/create: [List files]
+   - Dependencies: [Any prerequisites]
+   - Estimated effort: [time estimate]
+
+2. **Task Name**
+   - Description: [What needs to be done]
+   - Files to modify/create: [List files]
+   - Dependencies: [Any prerequisites]
+   - Estimated effort: [time estimate]
+
+### Phase 2: Core Implementation
+[Continue with numbered tasks...]
+
+### Phase 3: Integration & Testing
+[Continue with numbered tasks...]
+
+## Codebase Integration Points
+### Files to Modify
+- `path/to/file1.js` - [What changes needed]
+- `path/to/filen.py` - [What changes needed]
+
+### New Files to Create
+- `path/to/newfile1.js` - [Purpose]
+- `path/to/newfilen.py` - [Purpose]
+
+### Existing Patterns to Follow
+- [Pattern 1 from codebase]
+- [Pattern n from codebase]
+
+## Technical Design
+
+### Architecture Diagram (if applicable)
+```
+[ASCII diagram or description]
+```
+
+### Data Flow
+[Description of how data flows through the feature]
+
+### API Endpoints (if applicable)
+- `POST /api/endpoint` - [Purpose]
+- `GET /api/endpoint/:id` - [Purpose]
+
+## Dependencies and Libraries
+- [Library 1] - [Purpose]
+- [Library n] - [Purpose]
+
+## Testing Strategy
+- Unit tests for [components]
+- Integration tests for [workflows]
+- Edge cases to cover: [list]
+
+## Success Criteria
+- [ ] [Criterion 1]
+- [ ] [Criterion 2]
+- [ ] [Criterion n]
+
+## Notes and Considerations
+- [Any important notes]
+- [Potential challenges]
+- [Future enhancements]
+
+---
+*This plan is ready for execution with `/execute-plan`*
+```
+
+## Step 5: Validation
+
+Before finalizing the plan:
+1. Ensure all requirements are addressed
+2. Verify tasks are properly sequenced
+3. Check that integration points are identified
+4. Confirm research supports the approach
+5. Make sure the plan is actionable and clear
+
+## Important Guidelines
+
+- **Be thorough in research**: The quality of the plan depends on understanding best practices
+- **Keep it actionable**: Every task should be clear and implementable
+- **Reference everything**: Include links, file paths, and examples
+- **Consider the existing codebase**: Follow established patterns and conventions
+- **Think about testing**: Include testing tasks in the plan
+- **Size tasks appropriately**: Not too large, not too granular
+
+## Output
+
+Save the plan to the PRPs directory and inform the user:
+"Implementation plan created at: PRPs/[feature-name].md
+You can now execute this plan using: `/execute-plan PRPs/[feature-name].md`"
\ No newline at end of file
diff --git a/use-cases/ai-coding-workflows-foundation/commands/execute-plan.md b/use-cases/ai-coding-workflows-foundation/commands/execute-plan.md
new file mode 100644
index 0000000..97c6131
--- /dev/null
+++ b/use-cases/ai-coding-workflows-foundation/commands/execute-plan.md
@@ -0,0 +1,139 @@
+---
+description: Execute a development plan with full Archon task management integration
+argument-hint: [plan-file-path]
+---
+
+# Execute Development Plan with Archon Task Management
+
+You are about to execute a comprehensive development plan with integrated Archon task management. This workflow ensures systematic task tracking and implementation throughout the entire development process.
+
+## Critical Requirements
+
+**MANDATORY**: Throughout the ENTIRE execution of this plan, you MUST maintain continuous usage of Archon for task management. DO NOT drop or skip Archon integration at any point. Every task from the plan must be tracked in Archon from creation to completion.
+
+## Step 1: Read and Parse the Plan
+
+Read the plan file specified in: $ARGUMENTS
+
+The plan file will contain:
+- A list of tasks to implement
+- References to existing codebase components and integration points
+- Context about where to look in the codebase for implementation
+
+## Step 2: Project Setup in Archon
+
+1. Check if a project ID is specified in CLAUDE.md for this feature
+   - Look for any Archon project references in CLAUDE.md
+   - If found, use that project ID
+
+2. If no project exists:
+   - Create a new project in Archon using `mcp__archon__manage_project`
+   - Use a descriptive title based on the plan's objectives
+   - Store the project ID for use throughout execution
+
+## Step 3: Create All Tasks in Archon
+
+For EACH task identified in the plan:
+1. Create a corresponding task in Archon using `mcp__archon__manage_task("create", ...)`
+2. Set initial status as "todo"
+3. Include detailed descriptions from the plan
+4. Maintain the task order/priority from the plan
+
+**IMPORTANT**: Create ALL tasks in Archon upfront before starting implementation. This ensures complete visibility of the work scope.
+
+## Step 4: Codebase Analysis
+
+Before implementation begins:
+1. Analyze ALL integration points mentioned in the plan
+2. Use Grep and Glob tools to:
+   - Understand existing code patterns
+   - Identify where changes need to be made
+   - Find similar implementations for reference
+3. Read all referenced files and components
+4. Build a comprehensive understanding of the codebase context
+
+## Step 5: Implementation Cycle
+
+For EACH task in sequence:
+
+### 5.1 Start Task
+- Move the current task to "doing" status in Archon: `mcp__archon__manage_task("update", task_id=..., status="doing")`
+- Use TodoWrite to track local subtasks if needed
+
+### 5.2 Implement
+- Execute the implementation based on:
+  - The task requirements from the plan
+  - Your codebase analysis findings
+  - Best practices and existing patterns
+- Make all necessary code changes
+- Ensure code quality and consistency
+
+### 5.3 Complete Task
+- Once implementation is complete, move task to "review" status: `mcp__archon__manage_task("update", task_id=..., status="review")`
+- DO NOT mark as "done" yet - this comes after validation
+
+### 5.4 Proceed to Next
+- Move to the next task in the list
+- Repeat steps 5.1-5.3
+
+**CRITICAL**: Only ONE task should be in "doing" status at any time. Complete each task before starting the next.
+
+## Step 6: Validation Phase
+
+After ALL tasks are in "review" status:
+
+**IMPORTANT: Use the `validator` agent for comprehensive testing**
+1. Launch the validator agent using the Task tool
+   - Provide the validator with a detailed description of what was built
+   - Include the list of features implemented and files modified
+   - The validator will create simple, effective unit tests
+   - It will run tests and report results
+
+The validator agent will:
+- Create focused unit tests for the main functionality
+- Test critical edge cases and error handling
+- Run the tests using the project's test framework
+- Report what was tested and any issues found
+
+Additional validation you should perform:
+- Check for integration issues between components
+- Ensure all acceptance criteria from the plan are met
+
+## Step 7: Finalize Tasks in Archon
+
+After successful validation:
+
+1. For each task that has corresponding unit test coverage:
+   - Move from "review" to "done" status: `mcp__archon__manage_task("update", task_id=..., status="done")`
+
+2. For any tasks without test coverage:
+   - Leave in "review" status for future attention
+   - Document why they remain in review (e.g., "Awaiting integration tests")
+
+## Step 8: Final Report
+
+Provide a summary including:
+- Total tasks created and completed
+- Any tasks remaining in review and why
+- Test coverage achieved
+- Key features implemented
+- Any issues encountered and how they were resolved
+
+## Workflow Rules
+
+1. **NEVER** skip Archon task management at any point
+2. **ALWAYS** create all tasks in Archon before starting implementation
+3. **MAINTAIN** one task in "doing" status at a time
+4. **VALIDATE** all work before marking tasks as "done"
+5. **TRACK** progress continuously through Archon status updates
+6. **ANALYZE** the codebase thoroughly before implementation
+7. **TEST** everything before final completion
+
+## Error Handling
+
+If at any point Archon operations fail:
+1. Retry the operation
+2. If persistent failures, document the issue but continue tracking locally
+3. Never abandon the Archon integration - find workarounds if needed
+
+Remember: The success of this execution depends on maintaining systematic task management through Archon throughout the entire process. This ensures accountability, progress tracking, and quality delivery.
\ No newline at end of file
diff --git a/use-cases/ai-coding-workflows-foundation/commands/primer.md b/use-cases/ai-coding-workflows-foundation/commands/primer.md
new file mode 100644
index 0000000..5d9ab3e
--- /dev/null
+++ b/use-cases/ai-coding-workflows-foundation/commands/primer.md
@@ -0,0 +1,17 @@
+# Prime Context for the AI Coding Assistant (catch it up to speed on the project when starting a new conversation)
+
+Start with reading the CLAUDE.md file if it exists to get an understanding of the project.
+
+Read the README.md file to get an understanding of the project.
+
+Read key files in the directories:
+- backend_agent_api
+- backend_rag_pipeline
+- frontend
+
+Explain back to me:
+- Project structure
+- Project purpose and goals
+- Key files and their purposes
+- Any important dependencies
+- Any important configuration files
\ No newline at end of file