phase-implement

Coordinate implementation phase by delegating tasks and ensuring code quality. Use during implementation phase to manage engineer tasks.

⭐6stars🔀1forks📁View on GitHub🕐Updated Dec 11, 2025

When & Why to Use This Skill

The Implementation Coordination skill is designed to manage the software development lifecycle by bridging the gap between planning and execution. It specializes in decomposing complex technical specifications into granular tasks, delegating them based on engineering seniority, and enforcing rigorous code quality standards—such as 'zero-warnings' policies and high test coverage—to ensure robust and high-performance project delivery.

Use Cases

  • Transitioning from the planning phase to active development by breaking down deliverables into actionable tasks for different engineering roles.
  • Managing multi-agent workflows where complex tasks like SIMD optimization or memory management are delegated to senior agents while boilerplate code is assigned to junior agents.
  • Enforcing standardized code quality and performance benchmarks in Mojo-based projects through automated testing and formatting checklists.
  • Coordinating parallel workstreams between implementation, testing, and packaging phases to maintain project momentum and resolve blockers efficiently.
namephase-implement
description"Coordinate implementation phase by delegating tasks and ensuring code quality. Use during implementation phase to manage engineer tasks."
mcp_fallbacknone
categoryphase
phaseImpl
user-invocablefalse

Implementation Coordination Skill

Coordinate implementation phase by breaking down work, delegating to engineers, and maintaining quality standards.

When to Use

  • Starting implementation phase (after Plan completes)
  • Running in parallel with Test and Package phases
  • Need to delegate implementation tasks
  • Managing multiple engineering tasks simultaneously

Quick Reference

# Review GitHub issue for implementation tasks
gh issue view <number> --json body --jq '.body'

# Verify code quality
pixi run mojo test -I . tests/
pixi run mojo build -I . <module>
just pre-commit-all

# Check for warnings (zero-warnings policy)
# Any output = fix before committing

Workflow

  1. Review plan specifications - Understand deliverables and success criteria
  2. Break into tasks - Create granular implementation work items
  3. Delegate by complexity:
    • Senior Engineer: Complex algorithms, SIMD, memory management
    • Engineer: Standard implementations, business logic
    • Junior Engineer: Boilerplate, simple helpers, type definitions
  4. Monitor progress - Check completion status, unblock issues
  5. Code review - Verify quality, standards, tests, documentation
  6. Final checks - Format, lint, test coverage, no warnings

Delegation Matrix

Complexity Task Engineer
High Complex algorithms, SIMD optimizations Senior
High Memory management, ownership patterns Senior
Medium Standard functions, business logic Standard
Medium Data structures, operations Standard
Low Boilerplate, type aliases Junior
Low Simple helpers, constants Junior

Mojo Implementation Standards

Function definitions:

# High-performance critical
fn simd_add[dtype: DType](a: Tensor[dtype], b: Tensor[dtype]) -> Tensor[dtype]:
    """SIMD-optimized addition."""
    pass

# Flexible/Python interop
def load_model(path: String) -> PythonObject:
    pass

Memory management:

# Transfer ownership
fn process(owned data: Tensor) -> Tensor:
    return data^

# Read-only access
fn analyze(borrowed data: Tensor):
    pass

# Mutable access (Mojo v0.26.1+)
fn modify(mut data: Tensor):
    pass

Quality Checklist

Before code review approval:

  • All tests passing
  • 80% test coverage minimum
  • No compiler warnings (zero-warnings policy)
  • pixi run mojo format applied
  • Docstrings complete
  • No TODOs/FIXMEs (or documented)
  • Performance meets requirements
  • Follows Mojo syntax standards (Mojo v0.26.1+)

Phase Dependencies

  • Input from: Plan phase (specifications and deliverables)
  • Parallel with: Test phase (TDD) and Package phase
  • Precedes: Cleanup phase (after parallel phases complete)

Output Location

  • Implementation: /shared/<module>/, /examples/, /tooling/
  • Documentation: GitHub issue comments
  • Issue updates: Track progress, blockers, learnings via gh issue comment

Error Handling

Blocker Resolution
Unclear requirements Escalate to Design for clarification
Performance issues Consult Performance Specialist
Test failures Debug with Test Specialist
Missing dependencies Update Plan, communicate status
Compiler warnings Fix immediately (zero-warnings policy)

References

  • CLAUDE.md - "Mojo Syntax Standards" (current v0.26.1+ patterns)
  • CLAUDE.md - "Critical Pre-Flight Checklist" (before committing)
  • CLAUDE.md - "Common Mistakes to Avoid" (64+ test failure learnings)
  • notes/review/mojo-test-failure-learnings.md - Real implementation patterns

Key Principle: Implement to make tests pass, not the other way around.