harness-builder

Implement product specifications into incremental, tested source code.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/woink/harness-skills-plugin --skill harness-builder
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: harness-builder
Source: https://github.com/woink/harness-skills-plugin/tree/main/skills/harness-builder
Command: npx skills add https://github.com/woink/harness-skills-plugin --skill harness-builder

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Converts a planner's product specification into incrementally built, tested, and versioned source code while coordinating contracts with an independent evaluator, removing ad-hoc development and unclear acceptance criteria from the implementation phase.

Core Features & Use Cases

  • Sprint-by-sprint implementation: Proposes sprint contracts, implements features incrementally, and archives sprint artifacts.
  • Evaluator negotiation and QA handoff: Writes SPRINT_CONTRACT.md, waits for evaluator review, and hands off for cold QA with file-based state.
  • Existing project support: Reads CODEBASE_AUDIT.md, preserves architecture and conventions, and runs a Sprint 0 for housekeeping when needed.
  • Engineering discipline: Enforces test-driven development, git worktrees/commits per meaningful change, CI-friendly commits, and pre-handoff self-evaluation.
  • Polish & pivot workflows: Applies targeted refinements from POLISH_REPORT.md, supports pivot accept/reject flows, and documents recovery tags.
  • Context-sensitive documentation: Mandates Context7 lookups for accurate API and library usage before coding.

Quick Start

Use the harness-builder skill to implement the next sprint from .harness/PRODUCT_SPEC.md and draft .harness/SPRINT_CONTRACT.md for evaluator review.

Frequently Asked Questions about harness-builder

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

FAQPage Schema
How do I implement product specifications into tested source code incrementally?

To implement product specifications incrementally, you propose sprint contracts, enforce test-driven development, and archive sprint artifacts. This process converts specifications into versioned source code while coordinating acceptance criteria with an independent evaluator.

What is test-driven development with sprint contracts for software engineering?

Test-driven development with sprint contracts is a process where features are implemented incrementally based on a product spec, requiring a SPRINT_CONTRACT.md review by an evaluator before handoff. It ensures engineering discipline through enforced TDD and meaningful git commits per change.

How do I handle sprint-based builds for existing codebases without breaking conventions?

To handle sprint-based builds for existing codebases, you should read a CODEBASE_AUDIT.md file to preserve architecture and conventions. You can also run a Sprint 0 for housekeeping tasks to align the existing project before implementing new features.

Does this sprint-based implementation workflow support QA retries and polish iterations?

Yes, sprint-based implementation supports QA retries and polish iterations by handing off file-based state for cold QA and applying targeted refinements from a POLISH_REPORT.md. It also supports pivot accept and reject flows while documenting recovery tags.

Do I need specific file formats to start building code from a product spec?

You need to read and write .harness files to start building code from a product spec. Specifically, you reference .harness/PRODUCT_SPEC.md to plan the implementation and draft .harness/SPRINT_CONTRACT.md for the evaluator to review before coding begins.

When should I not use an incremental sprint implementation approach?

You should not use an incremental sprint implementation approach if your project lacks a clear product specification or an independent evaluator to review sprint contracts, as the workflow relies on negotiating acceptance criteria and file-based state handoffs to ensure code quality.