gf-implement

Automates project tasks by generating code and executing predefined workflows and checklists.

Updated Apr 4, 2026
One-click install
npx skills add https://github.com/ricky-yosh/agent-workflows --skill gf-implement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: gf-implement
Source: https://github.com/ricky-yosh/agent-workflows/tree/main/skills/greenfield/gf-implement
Command: npx skills add https://github.com/ricky-yosh/agent-workflows --skill gf-implement

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill directly handles the execution of the current user task by reading next-task.json and applying code changes with optional tests, bypassing manual planning.

Core Features & Use Cases

  • Directly implement the current task using the data from next-task.json.
  • Write tests when needed, implement the task, run verifications, and generate a digest documenting changes.
  • Works within the greenfield workflow to accelerate delivery when users select /gf-implement.

Quick Start

Invoke the gf-implement skill to complete the current task directly from next-task.json without planning.

Frequently Asked Questions about gf-implement

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

FAQPage Schema
How do I directly implement code changes from a task definition without manual planning?

Direct implementation without planning reads task context from next-task.json, writes required tests, implements code changes, runs verification suites, and generates a digest documenting modifications for validation.

How to write tests and implement code for greenfield tasks automatically?

Writing tests and implementing code for greenfield tasks executes directly from next-task.json data, applying code changes alongside optional tests, running the project test suite, and writing a validation digest to .aw/digests/.

What is a direct-greenfield task execution workflow and when do I need it?

Direct-greenfield task execution bypasses planning to accelerate delivery by reading task context, implementing code, executing verification suites, and documenting changes, which is needed when tasks are flagged for direct execution.

Does direct task implementation work without a planning phase?

Direct task implementation works without a planning phase by reading next-task.json and related files to execute code changes, write tests when needed, and perform verification directly within the greenfield workflow.

What's the best way to verify code changes and document them after implementation?

Verifying code changes and documenting them after implementation runs the project test suite for validation and writes a digest to .aw/digests/implement-task-N-digest.md detailing what changed and how to validate it.

When should I avoid bypassing planning for task implementation?

You should avoid bypassing planning for task implementation when tasks are not flagged for direct execution, as this approach is designed specifically for direct-greenfield tasks where context is already defined in next-task.json.