worker-implement

Implement vertical software slices using test-driven development and dependency injection.

1|Updated Mar 10, 2026
One-click install
npx skills add https://github.com/dayvidpham/pasture --skill worker-implement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: worker-implement
Source: https://github.com/dayvidpham/pasture/tree/main/.opencode/skill/worker-implement
Command: npx skills add https://github.com/dayvidpham/pasture --skill worker-implement

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the challenge of implementing complex software features in a fragmented way, ensuring that every vertical slice is fully owned, tested, and wired into the production path without creating technical debt or dual-code paths.

Core Features & Use Cases

  • Vertical Slice Ownership: Ensures developers own the full stack of a feature from types to wiring.
  • TDD-First Workflow: Enforces writing tests that import actual production code before implementation begins.
  • Validation-Case Contract: Integrates concrete validation cases into the definition of done for every request.
  • Use Case: When assigned a Beads task for a new CLI command, use this skill to plan backwards from the production code path, write tests that verify the feature's contract, and implement the service with real dependencies.

Quick Start

Use the worker-implement skill to guide the implementation of your assigned vertical slice task by following the backward planning and TDD steps.

Frequently Asked Questions about worker-implement

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

FAQPage Schema
How do I implement a vertical slice using test-driven development?

Implement a vertical slice with test-driven development by planning backwards from the production code path and writing tests that import actual production code before implementation begins. This ensures full-stack ownership without dual-code paths.

How does backward planning work for full-stack feature implementation?

Backward planning for feature implementation starts from the final production wiring path and traces dependencies backwards to define types and services. It enforces test-first verification and strict validation contracts before writing implementation code.

When do I need to use vertical slice ownership for Go development?

Vertical slice ownership is needed for Go feature development requiring full-stack ownership from types to wiring. It prevents fragmented implementation and technical debt by ensuring every slice is fully tested and wired into the production path.

What's the best way to enforce validation contracts during TDD implementation?

The best way to enforce validation contracts during TDD implementation is integrating concrete validation cases into the definition of done for every request. This requires test-first verification of the feature's contract before service implementation.

Does the worker-implement skill support safe shared-worktree git discipline?

The worker-implement skill supports safe shared-worktree git discipline by enforcing strict adherence to production-grade wiring and test-first verification. This ensures dependency injection and full-stack implementation align with validation contracts.