Execution Workflow

Provide structured workflow for task execution through delegation to specialized sub-agents, and comprehensive code review standards. Specialized sub-agents: quality_assurance (quality, security - parallel), implementation (test, refactor, docs - parallel if independent), review (sequential after implementation) Provide scope, file paths, Serena/Context7 tool instructions, reference implementations, memory checks Coding: Serena MCP → Context7 → Basic tools; Non-coding: Serena MCP → Context7 → Basic tools Execute independent tasks concurrently; quality+security can run in parallel, test+docs can run in parallel when independent Tasks with data dependencies must run in order; verify outputs before dependent tasks start Sub-agents need: specific scope, file paths, tool usage instructions, reference implementations, memory patterns Four phases: Initial scan (syntax), Deep analysis (logic), Context evaluation (impact), Standards compliance (naming/docs) Systematic code review process Has code been modified or newly created? Apply code review phases systematically to ensure quality</if_yes> Skip review and proceed to next task</if_no> </decision_tree> 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
</example>

Evaluation criteria for code quality Is this a code review or quality assessment task? Apply quality criteria across all dimensions</if_yes> Focus on implementation patterns instead</if_no> </decision_tree> 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
</example>

Categorization of review feedback by priority Have you identified issues during code review? Apply feedback categories to prioritize by severity</if_yes> Continue code review phases</if_no> </decision_tree> 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
</example>

Standard format for code review results Is it time to communicate code review findings? Apply review output format for structured communication</if_yes> Continue analyzing code through review phases</if_no> </decision_tree>

Overall assessment and recommendation

Must-fix items with file:line references</critical_issues> Should-fix items</important_issues> Optional improvements Good practices observed</positive_feedback> Clarifications needed 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> 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> 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 Sub-agent returns partial results Note in report, proceed Sub-agent task fails Document issue, use AskUserQuestion for clarification Critical task cannot be completed STOP, present options to user Sub-agent introduces breaking change BLOCK operation, require explicit user acknowledgment </error_escalation> Use for memory checks and symbol operations during delegation Use when code review reveals unclear implementation details Use to verify test coverage and quality during review </related_skills> Delegate detailed work to sub-agents Execute independent tasks in parallel Verify outputs before integration Implementing detailed logic directly Sequential execution of independent tasks Skipping verification of sub-agent outputs