Name: auto-implement-tasks
Author: yuhan3958

Prompt file imported from yuhan3958/Oort (.cursor/commands/tm/auto-implement-tasks.md). Fill in {{arguments}} before use. Copyright stays with the author.

Enhanced auto-implementation with intelligent code generation and testing.

Arguments: {{arguments}}

Intelligent Auto-Implementation

Advanced implementation with context awareness and quality checks.

1. Pre-Implementation Analysis

Before starting:

Analyze task complexity and requirements
Check codebase patterns and conventions
Identify similar completed tasks
Assess test coverage needs
Detect potential risks

2. Smart Implementation Strategy

Based on task type and context:

Feature Tasks

Research existing patterns
Design component architecture
Implement with tests
Integrate with system
Update documentation

Bug Fix Tasks

Reproduce issue
Identify root cause
Implement minimal fix
Add regression tests
Verify side effects

Refactoring Tasks

Analyze current structure
Plan incremental changes
Maintain test coverage
Refactor step-by-step
Verify behavior unchanged

3. Code Intelligence

Pattern Recognition

Learn from existing code
Follow team conventions
Use preferred libraries
Match style guidelines

Test-Driven Approach

Write tests first when possible
Ensure comprehensive coverage
Include edge cases
Performance considerations

4. Progressive Implementation

Step-by-step with validation:

Step 1/5: Setting up component structure ✓
Step 2/5: Implementing core logic ✓
Step 3/5: Adding error handling ⚡ (in progress)
Step 4/5: Writing tests ⏳
Step 5/5: Integration testing ⏳

Current: Adding try-catch blocks and validation...

5. Quality Assurance

Automated checks:

Linting and formatting
Test execution
Type checking
Dependency validation
Performance analysis

6. Smart Recovery

If issues arise:

Diagnostic analysis
Suggestion generation
Fallback strategies
Manual intervention points
Learning from failures

7. Post-Implementation

After completion:

Generate PR description
Update documentation
Log lessons learned
Suggest follow-up tasks
Update task relationships

Result: High-quality, production-ready implementations.

Install auto-implement-tasks and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

Enhanced auto-implementation with intelligent code generation and testing. Arguments: {{arguments}} ## Intelligent Auto-Implementation Advanced implementation with context awareness and quality checks. ### 1. **Pre-Implementation Analysis** Before starting: - Analyze task complexity and requirements - Check codebase patterns and conventions - Identify similar completed tasks - Assess test coverage needs - Detect potential risks ### 2. **Smart Implementation Strategy** Based on task type and context: **Feature Tasks** 1. Research existing patterns 2. Design component architecture 3. Implement with tests 4. Integrate with system 5. Update documentation **Bug Fix Tasks** 1. Reproduce issue 2. Identify root cause 3. Implement minimal fix 4. Add regression tests 5. Verify side effects **Refactoring Tasks** 1. Analyze current structure 2. Plan incremental changes 3. Maintain test coverage 4. Refactor step-by-step 5. Verify behavior unchanged ### 3. **Code Intelligence** **Pattern Recognition** - Learn from existing code - Follow team conventions - Use preferred libraries - Match style guidelines **Test-Driven Approach** - Write tests first when possible - Ensure comprehensive coverage - Include edge cases - Performance considerations ### 4. **Progressive Implementation** Step-by-step with validation: ``` Step 1/5: Setting up component structure ✓ Step 2/5: Implementing core logic ✓ Step 3/5: Adding error handling ⚡ (in progress) Step 4/5: Writing tests ⏳ Step 5/5: Integration testing ⏳ Current: Adding try-catch blocks and validation... ``` ### 5. **Quality Assurance** Automated checks: - Linting and formatting - Test execution - Type checking - Dependency validation - Performance analysis ### 6. **Smart Recovery** If issues arise: - Diagnostic analysis - Suggestion generation - Fallback strategies - Manual intervention points - Learning from failures ### 7. **Post-Implementation** After completion: - Generate PR description - Update documentation - Log lessons learned - Suggest follow-up tasks - Update task relationships Result: High-quality, production-ready implementations.

{ "prompt": "Enhanced auto-implementation with intelligent code generation and testing.\n\nArguments: {{arguments}}\n\n## Intelligent Auto-Implementation\n\nAdvanced implementation with context awareness and quality checks.\n\n### 1. **Pre-Implementation Analysis**\n\nBefore starting:\n- Analyze task complexity and requirements\n- Check codebase patterns and conventions\n- Identify similar completed tasks\n- Assess test coverage needs\n- Detect potential risks\n\n### 2. **Smart Implementation Strategy**\n\nBased on task type and context:\n\n**Feature Tasks**\n1. Research existing patterns\n2. Design component architecture\n3. Implement with tests\n4. Integrate with system\n5. Update documentation\n\n**Bug Fix Tasks**\n1. Reproduce issue\n2. Identify root cause\n3. Implement minimal fix\n4. Add regression tests\n5. Verify side effects\n\n**Refactoring Tasks**\n1. Analyze current structure\n2. Plan incremental changes\n3. Maintain test coverage\n4. Refactor step-by-step\n5. Verify behavior unchanged\n\n### 3. **Code Intelligence**\n\n**Pattern Recognition**\n- Learn from existing code\n- Follow team conventions\n- Use preferred libraries\n- Match style guidelines\n\n**Test-Driven Approach**\n- Write tests first when possible\n- Ensure comprehensive coverage\n- Include edge cases\n- Performance considerations\n\n### 4. **Progressive Implementation**\n\nStep-by-step with validation:\n```\nStep 1/5: Setting up component structure ✓\nStep 2/5: Implementing core logic ✓\nStep 3/5: Adding error handling ⚡ (in progress)\nStep 4/5: Writing tests ⏳\nStep 5/5: Integration testing ⏳\n\nCurrent: Adding try-catch blocks and validation...\n```\n\n### 5. **Quality Assurance**\n\nAutomated checks:\n- Linting and formatting\n- Test execution\n- Type checking\n- Dependency validation\n- Performance analysis\n\n### 6. **Smart Recovery**\n\nIf issues arise:\n- Diagnostic analysis\n- Suggestion generation\n- Fallback strategies\n- Manual intervention points\n- Learning from failures\n\n### 7. **Post-Implementation**\n\nAfter completion:\n- Generate PR description\n- Update documentation\n- Log lessons learned\n- Suggest follow-up tasks\n- Update task relationships\n\nResult: High-quality, production-ready implementations.", "variables": [ "arguments" ], "notes": "Enhanced auto-implementation with intelligent code generation and testing.", "metadata": { "source": { "provider": "github-cursor-commands", "repository": "https://github.com/yuhan3958/Oort", "path": ".cursor/commands/tm/auto-implement-tasks.md", "ref": "1821db0f8d03e02ce02817088d55a739cb1d7e23", "url": "https://github.com/yuhan3958/Oort/blob/1821db0f8d03e02ce02817088d55a739cb1d7e23/.cursor/commands/tm/auto-implement-tasks.md", "key": "yuhan3958/Oort/.cursor/commands/tm/auto-implement-tasks.md" } } }

auto-implement-tasks

About

Intelligent Auto-Implementation

1. Pre-Implementation Analysis

2. Smart Implementation Strategy

3. Code Intelligence

4. Progressive Implementation

5. Quality Assurance

6. Smart Recovery

7. Post-Implementation

Install auto-implement-tasks and it becomes one more candidate the router can pick - when it fits.

Use it

Manifest

Reviews