External/context-engineering-intro
1
0
Fork 0
mirror of https://github.com/coleam00/context-engineering-intro.git synced 2025-12-29 16:14:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

AI Coding Workflow Commands and Subagents

Browse Source
This commit is contained in:
Cole Medin
2025-09-24 17:54:38 -05:00
parent 9f9f23efd4
commit 8c8a216387
6 changed files with 737 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
use-cases/ai-coding-workflows-foundation/commands/create-plan.md Normal file
View File

@@ -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`"

139
use-cases/ai-coding-workflows-foundation/commands/execute-plan.md Normal file
View File

@@ -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.

17
use-cases/ai-coding-workflows-foundation/commands/primer.md Normal file
View File

@@ -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