tGD

AI-DRIVEN PDLC · 2026

The Agentic
PDLC Harness

Your PDLC was built for humans. Now agents do the work.
tGD wraps your product development lifecycle in the gates your team already trusts — spec before code, tests before claims, human sign-off before release.

🗺️Map
→
📋Define
→
📐Plan
→
⚡Develop
→
🧪Verify
→
🔎Review
→
🚀Release
Claude Code Codex CLI Gemini CLI OpenCode Pi Hermes
Press T to toggle dark/light · ← → to navigate

THE PROBLEM

AI agents can write code.
Nobody holds them accountable.

💬 "Should work"

The agent claims success — but the tests never ran. No evidence, no proof, no accountability.

📝 500 lines before reading

It writes a novel before it has understood a single file of your codebase.

💥 Broken PR, agent gone

No spec, no plan, no tests. It ships garbage and moves on to the next prompt.

The harness matters as much as the model.
— the principle behind tGD
Problem

THE SOLUTION

tGD is the harness
for AI-driven development.

A seven-stage pipeline that forces agents to read before writing, spec before coding, and test before claiming done — with a human sign-off at every gate.

29
Skills
7
Stages
6
Platforms
3
Personas

Open source · Apache 2.0 · plain Markdown skills — no server, no telemetry, your code never leaves your tools.

Solution

HOW IT WORKS

Seven stages. Every output feeds the next.

🗺️
1 · MAP
Scan the codebase → CONTEXT.md
tgd-core-context + codegraph
📋
2 · DEFINE
PRD → 0/2/3 design → SPEC
tgd-define-interview → tgd-define-spec + tgd-define-sketch
📐
3 · PLAN
Context-grounded breakdown → TASKS.md
planning → jira-sync
⚡
4 · DEVELOP
Worktree + TDD → src/ + tests/
tgd-develop-source → tgd-develop-tdd
🧪
5 · VERIFY
Tests + UI evidence → TEST-REPORT.md
debugging → regression + design QA
🔎
6 · REVIEW
Code + design conformance → REVIEW.md
tgd-review-quality → tgd-review-simplify
🚀
7 · RELEASE
Commit + CI → CHANGELOG + METRICS
tgd-core-git → tgd-release-ship
🔁
THE LOOP
Verify fails? Work goes back to Develop.
Nothing broken reaches Release.
Pipeline — every stage gated

HUMAN GATES

Agents do the work.
Humans hold the keys.

Every stage produces an artifact with a sign-off section. The next stage will not start until the right person checks the box.

PM — Product

Owns direction and acceptance.
Signs PRD.md and the final Release.

DESIGN — Experience

Approves direction in DESIGN.md and built-UI conformance in REVIEW.md.

DEV — Implementation

Owns code quality.
Signs TASKS.md, the code, and REVIEW.md.

QA — Evidence

Owns test quality and coverage.
Signs TEST-REPORT.md and REVIEW.md.

Release gate — all must be [x]
PRD.md         → - [x] PM  ✓
DESIGN.md      → - [x] DESIGN direction ✓   (UI)
TASKS.md       → - [x] DEV ✓
TEST-REPORT.md → - [x] QA  ✓   (regression 100%)
REVIEW.md      → - [x] QA + DEV ✓
               → - [x] DESIGN implementation ✓   (UI)
One person can hold multiple roles — git is the only coordination tool.
Human gates — sign-off before the next stage

COMMANDS 1–3 · DEFINE THE WORK

Context first. Spec before code.

/tgd-map

Scans your codebase — tech stack, architecture, patterns — and builds an offline knowledge graph.

→ CONTEXT.md

/tgd-define

Interviews for intent, writes the PRD, routes UI to 0/2/3 prototypes, gets direction approval, then finalizes the technical spec.

→ PRD.md · DESIGN.md (UI) · SPEC.md

/tgd-plan

Reads CONTEXT + PRD + approved DESIGN (UI) + SPEC and decomposes the work into atomic tasks with BDD acceptance criteria.

→ TASKS.md (Given/When/Then, [R] markers)
💡 Each command refuses to run until the previous stage's artifact exists and is signed off — that's the pre-flight check.
Define the work — Map · Define · Plan

COMMAND 4 · BUILD IT

/tgd-develop — isolated, routed, test-driven.

🏖️ Mandatory worktree isolation

Code is written in a Git worktree sandbox. A failed experiment? Delete the worktree — your plans are untouched.

🔀 Smart execution routing

< 3 tasks → the main agent implements directly.
≥ 3 tasks → parallel subagents with two-stage review: spec compliance, then code quality.

🔴🟢 TDD, not tests-after

Red → Green → Refactor for every task. The BDD criteria from TASKS.md become the tests.

Worktree
<project>-jwt-auth/          ← sandbox
├── src/
│   ├── middleware/auth.ts
│   └── routes/auth.ts
└── tests/
    ├── auth.test.ts         [R]
    └── login.test.ts        [R]

Per task:
  1. test first (red)
  2. implement (green)
  3. refactor — tests stay green
Build it — mandatory worktree + smart routing

COMMAND 5 · PROVE IT

/tgd-verify — the hard gate.

Tests are proof. Not confidence, not "looks right" — output.

1 · Run everything

Unit, integration, E2E, and design conformance. UI evidence is tied to the tested commit, viewport, and runtime state.

2 · Cross-feature regression

Reads REGRESSION-CATALOG.md and re-runs every [R] test from every previously shipped feature.

3 · Block on failure

Any red test stops the pipeline. Work goes back to Develop. No merge, no ship, no exceptions.

TEST-REPORT.md
## Summary
Total: 12   Passed: 12   Failed: 0
Regression: 5/5 ✓
Catalog:   19/19 ✓  (cross-feature)

## Evidence
[R] test_valid_jwt        ✅
[R] test_wrong_password   ✅
    test_empty_password   ✅
    screenshot: login-e2e.png ✅

Sign-off:
  - [ ] QA: (pending)
Prove it — tests are proof

COMMANDS 6–7 · SHIP IT

Review the health. Release with a trail.

/tgd-review — five axes

1 · Correctness — does it do what SPEC says?
2 · Maintainability — can someone else read it?
3 · Security — OWASP + secrets management
4 · Performance — no N+1, no waste
5 · Test coverage — 80% unit · 15% integration · 5% E2E
→ REVIEW.md (QA + DEV; DESIGN signs UI conformance)

/tgd-release — faster is safer

· Atomic commits, CI green, staged rollout
· Regression catalog updated with this feature's [R] tests — the safety net grows
· ADRs for architectural decisions
· METRICS.md — KPI handoff for post-launch tracking
→ CHANGELOG.md · METRICS.md (PM signs)
🤖 Backed by three reviewer personas — code-reviewer · test-engineer · security-auditor — you (or the command) orchestrate them.
Ship it — Review · Release

WHY IT COMPOUNDS

It's not a loop. It's a spiral.

Each feature runs the full seven-stage pipeline — and leaves the codebase stronger than it found it. The next feature starts on that higher floor. A cycle returns to where it began; tGD ratchets.

Feature 1 Feature 2 Feature 3 Feature 4 — higher still start
Three things accumulate on every loop — the pipeline never resets to zero:
🛡️
Regression catalog
Every feature's acceptance tests join it. The safety net only ever gets denser.
🗺️
CONTEXT.md
Re-mapped each loop against the now-larger codebase — understanding deepens.
📈
CHANGELOG + METRICS
A durable audit trail of what shipped and what it moved.
A cycle returns to the same place. tGD ratchets — every release raises the floor the next feature builds on.
The spiral — every release raises the floor

TESTING STRATEGY

Three roles. One rule:
no shortcuts.

🔨 Builder

/tgd-develop

Writes tests alongside code.
Red → Green → Refactor.

🔍 Inspector

/tgd-verify

Runs ALL tests + browser E2E.
Reproduce → Localize → Fix → Guard.

🕵️ Auditor

/tgd-review

Audits test quality.
80% unit · 15% integration · 5% E2E.

Why separate roles? The one who writes the code never gets to be the only one who judges it — separation is what prevents "lazy agent" behavior.

Testing strategy — builder, inspector, auditor

GETTING STARTED

Thirty seconds to install.
One command to start.

Terminal
# Clone & install (30s)
$ git clone https://github.com/\
  yhwangtw/tgd.git
$ cd tgd && bash setup.sh

# Start any agent
$ claude · codex · gemini
$ opencode · pi · hermes

# Initialize, then build
$ /tgd-map
$ /tgd-define add user auth

Platform support

Claude Code — native commands + skills
Codex CLI — prompt-based integration
Gemini CLI — native commands
OpenCode — auto-detected skills
Pi — TypeScript extension
Hermes Agent — Python plugin + hooks

One setup.sh detects what you have and links the right format for each.

Quick start

READY TO SHIP?

Stop vibe-coding.
Start shipping.

tGD turns your AI agent from a code generator
into a disciplined engineering partner.

git clone https://github.com/yhwangtw/tgd.git
cd tgd && bash setup.sh
claude  # then: /tgd-map
⭐ Star on GitHub Apache 2.0 6 Platforms
yhwangtw/tgd