implement

Orchestrate end-to-end feature development workflows across planning, batching, verification, and review.

6|Updated Mar 30, 2026
One-click install
npx skills add https://github.com/moberghr/mtk-agent-toolkit --skill implement-moberghr
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implement
Source: https://github.com/moberghr/mtk-agent-toolkit/tree/main/.claude/skills/implement
Command: npx skills add https://github.com/moberghr/mtk-agent-toolkit --skill implement-moberghr

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill centralizes the orchestration of MTK's end-to-end feature delivery workflow, ensuring planning, batching, verification, and review occur in a cohesive, auditable loop rather than as ad-hoc tasks.

Core Features & Use Cases

  • End-to-end feature loop orchestration across planning, implementation, testing, and review, reducing handoff friction and drift.
  • Coordinates multiple sub-skills (context engineering, spec-driven development, incremental implementation, test-driven development, and code review) to deliver consistent outcomes.
  • Use case: when delivering a large feature across several teams and stacks, this Skill coordinates artifacts, gates, and documentation to ensure traceability and quality.

Quick Start

Invoke the implement skill to orchestrate the full feature delivery loop from planning to gate-compliant reviews.

Frequently Asked Questions about implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I orchestrate end-to-end feature delivery across planning, implementation, and review?

End-to-end feature delivery is orchestrated by coordinating planning, batching, verification, and code review into a cohesive, auditable loop rather than ad-hoc tasks. This reduces handoff friction and aligns multi-phase software initiatives with the active tech stack.

What is spec-driven development and how does it fit into feature implementation?

Spec-driven development is a coordinated sub-skill within feature implementation that uses specifications to drive consistent outcomes. It operates alongside context engineering and incremental implementation to ensure traceability and quality across the delivery workflow.

How do I coordinate multiple teams and tech stacks for a large software feature?

Coordinating large features across teams and stacks requires centralizing artifacts, gates, and documentation within a single workflow loop. This ensures traceability and quality by aligning sub-skills like test-driven development and code review across the initiative.

Can I use incremental implementation with test-driven development for multi-phase software initiatives?

Incremental implementation works directly with test-driven development as coordinated sub-skills within the feature loop. Together they drive consistent outcomes across multi-phase software initiatives spanning specification, implementation, testing, and governance.

Does feature delivery orchestration support automated code review and quality assurance gates?

Feature delivery orchestration includes quality assurance and code review as core components of its workflow loop. These verification phases produce auditable artifacts that ensure traceability and gate-compliant reviews before feature completion.

Why does my feature implementation drift across handoffs between planning and review?

Feature implementation drifts across handoffs when planning, batching, and verification occur as ad-hoc tasks. Centralizing these phases into a cohesive orchestration loop reduces friction and ensures artifacts remain aligned throughout development.