| name | Execution Workflow |
| description | This skill should be used when the user asks to "execute task", "implement feature", "delegate work", "run workflow", "review code", "code quality check", or needs task orchestration and code review guidance. Provides execution, delegation, and code review patterns. |
| version | 0.2.0 |
Provide structured workflow for task execution through delegation to specialized sub-agents, and comprehensive code review standards.
Understand requirements and identify scope
Parse task description for key objectives
Identify affected files and components
Check Serena memories for existing patterns
Split into manageable units
Identify atomic tasks
Estimate complexity of each task
Assign to appropriate sub-agents
Identify parallel vs sequential execution
Map task dependencies
Group independent tasks for parallel execution
Order dependent tasks sequentially
Assign to sub-agents with detailed instructions
Provide specific scope and expected deliverables
Include target file paths
Specify MCP tool usage instructions
Reference existing implementations
Verify and combine results
Review sub-agent outputs
Resolve conflicts between outputs
Ensure consistency across changes
Specialized sub-agents organized by execution model
Syntax, type, format verification
Vulnerability detection
Test creation, coverage
Refactoring, tech debt
Documentation updates
Post-implementation review
Essential information to provide when delegating to sub-agents
- Specific scope and expected deliverables
- Target file paths
- Serena MCP usage: find_symbol, get_symbols_overview, search_for_pattern
- Context7 MCP usage for library verification
- Reference implementations with specific paths
- Memory check: list_memories for patterns
Tool selection hierarchy for task execution
For coding tasks (generation/modification/review):
Priority 1: Codex MCP (sandbox: workspace-write, approval-policy: on-failure)
Priority 2: Serena MCP for symbol operations and memory
Priority 3: Context7 for library documentation
Priority 4: Basic tools (Read/Edit/Write) as fallback
For non-coding tasks (research/analysis):
Priority 1: Serena MCP for symbol search and memory
Priority 2: Context7 for library documentation
Priority 3: Basic tools (Read/Edit/Write)
Codex MCP configuration:
- sandbox: workspace-write (allows code generation/modification)
- approval-policy: on-failure (auto-approve commands when execution fails)
Prohibited Codex usage:
- Research/analysis - use Explore agent, Serena MCP
- Documentation generation - use docs agent
Allowed Codex usage:
- Code generation (new files/functions)
- Code modification (editing/refactoring)
- Code review and quality analysis
- Test code generation
- Performance optimization suggestions
Systematic code review process
Phase 1 - Initial Scan:
- Syntax errors and typos
- Missing imports or dependencies
- Obvious logic errors
- Code style violations
Phase 2 - Deep Analysis:
- Algorithm correctness
- Edge case handling
- Error handling completeness
- Resource management
Phase 3 - Context Evaluation:
- Breaking changes to public APIs
- Side effects on existing functionality
- Dependency compatibility
Phase 4 - Standards Compliance:
- Naming conventions
- Documentation requirements
- Test coverage
Evaluation criteria for code quality
Correctness:
- Logic matches requirements
- Edge cases handled
- Error conditions covered
Security:
- Input validation
- Authentication/authorization
- Data sanitization
- Secrets handling
Performance:
- Algorithm efficiency
- Resource usage
- Memory leaks
- N+1 queries
Maintainability:
- Clear naming
- Appropriate comments
- Single responsibility
- DRY principle
Testability:
- Test coverage adequate
- Tests meaningful
- Edge cases tested
Categorization of review feedback by priority
Critical: Must fix before merge
- Security vulnerabilities
- Data corruption risks
- Breaking changes
Important: Should fix before merge
- Logic errors
- Missing error handling
- Performance issues
Suggestion: Nice to have improvements
- Code style
- Refactoring opportunities
- Documentation
Positive: What was done well
- Good patterns
- Clever solutions
- Thorough testing
Standard format for code review results
Overall assessment and recommendation
Must-fix items with file:line references
Should-fix items
Optional improvements
Good practices observed
Clarifications needed
Execute independent tasks in parallel
Never parallelize tasks with data dependencies
Verify sub-agent outputs before integration
Run quality checks after changes
quality + security: Concurrent checks
test + docs: Simultaneous creation when independent
Ensure no regression in existing functionality
Confirm all acceptance criteria met
<best_practices>
Analyze task dependencies before execution to determine parallel vs sequential execution model
Provide comprehensive context to sub-agents including file paths, tool usage, and reference implementations
Systematically review all phases: initial scan, deep analysis, context evaluation, standards compliance
Balance critical feedback with positive observations of good practices
Provide file:line references and concrete improvement suggestions
Check Serena memories for existing patterns before delegating implementation tasks
</best_practices>
<anti_patterns>
Focusing on code style issues when functionality is broken
Address critical and important issues first, style suggestions last
Approving changes without thorough review
Systematically review all phases: scan, deep analysis, context, standards
Providing only critical feedback without acknowledging good work
Balance feedback with positive observations of good practices
Giving feedback without specific, actionable suggestions
Provide file:line references and concrete improvement suggestions
Executing independent tasks sequentially
Identify and execute independent tasks in parallel for efficiency
Attempting to parallelize tasks with data dependencies
Analyze dependencies and execute dependent tasks sequentially
</anti_patterns>
