---
title: Workflow Patterns
category: product
entity_type: skill
price: $15
canonical: https://forgehouse.ai/skills/workflow-patterns/
lang: en
hreflang_alt: https://forgehouse.ai/tr/skiller/workflow-patterns/
last_updated: 2026-06-20
---

# Workflow Patterns

> When implementing tasks according to Conductor's TDD workflow, handling phase checkpoints…

A disciplined 11-step TDD task lifecycle that walks every feature from a failing test (RED) through minimum implementation (GREEN), refactor, coverage check, atomic commit and phase checkpoint. It enforces quality gates and human-approved checkpoints so work is never marked 'done' until it actually passes, and every commit leaves the codebase in a working, revertible state.

## Use cases
- Driving feature work strictly through red-green-refactor
- Managing phase checkpoints with restore points
- Recording rich git notes and SHA traceability in plan files
- Enforcing 80% coverage and quality gates before completion
- Documenting deviations (scope add/reduce, technical, requirement change)
- Recovering cleanly from failed tests or rejected checkpoints

## Benefits
- Every commit is atomic and leaves the build green, so git bisect and rollback stay clean
- Checkpoint discipline gives you a safe revert point at the end of every phase
- Six mandatory quality gates stop technical debt from sneaking into 'completed' work
- Deviation tracking preserves the 'why' behind every change for future maintainers

## What’s included
- The full 11-step task lifecycle from RED to plan-update commit
- Phase completion protocol with manual verification checklist and explicit approval gate
- Quality-gate checklist (passing tests, coverage, lint, types, security audit)
- Conventional commit message format with type/scope/body/footer
- Git notes templates for rich task summaries and decisions
- TDD variations per task type (data model, API endpoint, integration, refactor)

## Who it’s for
Engineers and teams who want test-driven discipline with auditable checkpoints, atomic commits and zero half-finished work.

## How it runs
Eleven steps per task, one checkpoint per phase, and a hard stop that waits for your approval. Every commit gets its SHA written back into the plan, so any phase can be rolled back cleanly.
1. Picks the next pending task from plan.md in order, marks it in-progress and commits that status change separately from any code.
2. Runs RED first: writes failing tests covering happy path, edge cases and error conditions before any implementation exists, then GREEN with the minimum code to pass, then REFACTOR while re-running tests after every change to keep them green.
3. Verifies coverage against the 80 percent target with a missing-lines report, adds tests for uncovered paths, and documents any deviation (scope add, scope cut, technical change, requirement change) in spec.md and plan.md.
4. Commits atomically with a typed message (feat/fix/refactor plus task and track references), attaches a rich git note (summary, files, decisions), then records the commit SHA next to the task in plan.md as a separate docs commit.
5. At phase end runs the verification protocol: diffs all files since the last checkpoint, runs the full suite plus lint and type check, generates a manual verification checklist and explicitly WAITS for user approval, never proceeding without it.
6. After approval creates the checkpoint commit and writes its SHA into the plan's checkpoints table, giving every phase a semantic restore point that git revert can roll back to safely.

## FAQ
### Is this tied to Conductor, or can any team adopt the lifecycle?
It is built around Conductor's plan.md tracks, phase checkpoints and verification protocol, but the 11-step lifecycle itself (RED, GREEN, refactor, coverage, atomic commit, checkpoint) works as a general TDD discipline for any team willing to follow the gates.

### What actually stops work from being marked done before it really is?
Two mechanisms: six mandatory quality gates (passing tests, 80% coverage, lint, types, security audit) and a phase checkpoint that requires a manual verification checklist plus explicit human approval. Until both pass, the task cannot close, and every commit must leave the build green.

### Is this the same thing as workflow-orchestration-patterns?
No. That skill orchestrates distributed systems on Temporal; this one is a developer task lifecycle: red-green-refactor steps, conventional commits, git notes with SHA traceability, deviation documentation and restore points. Same word, completely different layer.

## Price
$15, one-time, no subscription. VAT included.

Related guide: [AI code review and developer workflow](https://forgehouse.ai/guides/ai-code-review/)