implement

Execute validated implementation plans with task tracking and code-review automation.

6|1|Updated Dec 30, 2025
One-click install
npx skills add https://github.com/ferdiangunawan/rpi-stack --skill implement-ferdiangunawan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implement
Source: https://github.com/ferdiangunawan/rpi-stack/tree/main/implement
Command: npx skills add https://github.com/ferdiangunawan/rpi-stack --skill implement-ferdiangunawan

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill automates the end-to-end implementation workflow, ensuring plans are executed with rigorous progress tracking, gated quality checks, and auditable outcomes.

Core Features & Use Cases

  • Phase-based execution: orchestrates preparation, execution, verification, and review phases with mandatory progress updates.
  • Per-task discipline: enforces one-task-at-a-time execution, acceptance criteria verification, and lint/testing integration.
  • Background audits: spawns periodic security and performance audits to surface issues early and drive remediation.
  • Code review automation: triggers code-review step after implementation and consolidates results for stakeholder sign-off.
  • Progress telemetry: updates the RPI session after each task to reflect completion, next steps, and overall progress.

Quick Start

Invoke /implement to start implementing the validated plan.

Frequently Asked Questions about implement

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

FAQPage Schema
How do I automate feature implementation with progress tracking and quality gates?

Automating feature implementation requires orchestrating phase-based execution with per-task discipline and progress telemetry. This workflow enforces preparation, execution, verification, and review phases while applying linting, testing, and mandatory progress updates after each completed task.

What is phase-based execution for software task management?

Phase-based execution is a task-management method that mandates one-task-at-a-time completion across distinct preparation, execution, verification, and review stages. It enforces acceptance criteria verification and linting before moving forward, ensuring rigorous progress tracking and auditable outcomes.

How do I run background security and performance audits during code implementation?

Running background audits during code implementation involves spawning periodic security and performance checks alongside active development. This mechanism surfaces issues early, driving immediate remediation before the final code-review automation phase triggers for stakeholder sign-off.

Can I enforce per-task acceptance criteria verification and linting in my workflow?

Yes, you can enforce per-task acceptance criteria verification and linting by applying a strict one-task-at-a-time execution model. This discipline ensures each task passes integration checks and acceptance criteria before updating progress telemetry and moving to the next phase.

Do I need a validated plan before starting automated code implementation?

Yes, a validated plan is required before starting automated code implementation. The workflow relies on following the validated plan to orchestrate end-to-end execution, enforce per-task discipline, and provide auditable outcomes through structured progress tracking.

What's the best way to automate code review after completing a feature implementation?

The best way to automate code review after feature implementation is to trigger a dedicated code-review step upon task completion. This consolidates results from background audits and per-task verification, providing a unified outcome for stakeholder sign-off.