dev-worker

Executes software development tasks with test-driven verification and documented outputs.

4|Updated Dec 7, 2025
One-click install
npx skills add https://github.com/grigb/gas-prompt-library --skill dev-worker
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dev-worker
Source: https://github.com/grigb/gas-prompt-library/tree/main/agents/agent-dev-worker
Command: npx skills add https://github.com/grigb/gas-prompt-library --skill dev-worker

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the need for systematic, evidence-based software development, debugging, and testing, ensuring that complex technical tasks are executed with high autonomy and verifiable results.

Core Features & Use Cases

  • Systematic Implementation: Handles feature work, bug fixes, and refactoring with a strict four-phase development protocol.
  • Evidence-Based Verification: Ensures all changes are backed by test results, logs, and terminal output before claiming completion.
  • Use Case: When a production bug occurs, use this agent to investigate the root cause, implement a fix, verify it with a test suite, and document the resolution in the project's working memory.

Quick Start

Invoke the dev-worker skill to analyze the current repository state and begin implementing the requested feature or bug fix following the standard development protocol.

Frequently Asked Questions about dev-worker

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

FAQPage Schema
How do I automate debugging and feature implementation within a single project scope?

Automated debugging and implementation within a single project scope is handled by executing a strict four-phase development protocol that manages technical execution, maintains working memory, and provides evidence-backed status updates throughout the process.

What is test-driven verification for software development tasks?

Test-driven verification for software development tasks is the process of ensuring all code changes are backed by test results, logs, and terminal output before a task is considered complete, guaranteeing evidence-based results for bug fixes and features.

How do I manage atomic changes during code refactoring and bug fixes?

Managing atomic changes during refactoring and bug fixes requires adherence to strict development protocols that isolate modifications, ensuring systematic implementation and verifiable output collection for each distinct technical execution step.

Does this development approach work for investigating and resolving production bugs?

Yes, this development approach works for production bugs by investigating the root cause, implementing a fix, verifying the resolution with a test suite, and documenting the outcome in the project's working memory.

What are the limitations of high-autonomy technical execution for coding tasks?

High-autonomy technical execution for coding tasks is limited to single-project scopes and requires strict adherence to development protocols, meaning it operates within defined boundaries to maintain verifiable output collection rather than spanning multiple repositories.