PRP Workflow

PRP is how FIT makes agent work deterministic.

A chat-driven agent will produce a different answer every time. A FIT agent running a PRP will produce the same artifacts, run the same validations, and leave the same evidence — across providers, across harnesses, across sessions.

Set and forget once configured. That is the claim. PRP is what backs it.

The PIV loop shows where plans, implementation, review gates, and AI Layer updates happen.

The vocabulary

Term	Meaning
PRD	Product Requirement Document. What is being built and why.
PRP	Product Requirement Prompt. PRD plus curated codebase intelligence plus a bounded execution runbook. The single artifact an agent reads to do the work.
PIV	Plan → Implement → Validate. The execution unit inside a PRP. Each PIV maps to a branch and commit boundary so it can be reverted without losing the whole effort.
Evidence block	The required proof section at the end of a PIV showing what was validated, what commands ran, what outputs were observed, and what still needs human review.

Source: fit-solutions/.agent/skills/prp.md.

The loop

PRD  →  PRP (plan)  →  PIV 1  →  validate  →  evidence  →  approval
                       PIV 2  →  validate  →  evidence  →  approval
                       PIV n  →  validate  →  evidence  →  merge

Every executable phase decomposes into one or more bounded PIV units. Every PIV has a discrete validation section and evidence block. Every PIV maps to a commit boundary. Human approval is required before merge, before publish, and before advancing past any defined approval checkpoint.

A plan that does not state its rollback boundary and evidence requirements is incomplete and will not be executed.

The AI Layer

The AI Layer is the shared context every run loads: AGENT.md, skills, repo-scaffold guides, alignment checks, and system prompts. It is the part that makes one run line up with the next.

The loop reads the full AI Layer at Prime (node 0) and Implement (node 4). Those are the fresh-context points where the agent needs the current rules, skills, and repo shape before it acts.

The loop writes curated changes back at Plan Review (Gate 2) and HERO GATE / System Evolution (Gate 4). Human-reviewed improvements flow into the AI Layer, so the next run starts with better context.

Required PIV sections

# [PIV] Title

## Objective
## Scope
## Constraints / Allowed Actions
## Implementation Notes
## Validation
- [ ] command

## Evidence Required
- [ ] proof of validation

## Rollback Boundary
## Approval Checkpoint

If the change is large, the phase plan also carries a PIV table:

| PIV | Goal | Status | Depends | Evidence |
|-----|------|--------|---------|----------|
| 1.1 | ...  | pending| -       | -        |

Status lifecycle: pending → in-progress → complete.

Artifacts on disk

Every repo that runs PRP has a .agent/prp/ directory:

.agent/prp/
├── prds/             # Product requirement documents
├── plans/            # Implementation plans
│   └── completed/    # Archived completed plans
├── reports/          # Implementation reports
├── issues/           # Issue investigation artifacts
│   └── completed/
├── reviews/          # PR review reports
├── templates/        # Reusable PRP/PIV templates
└── evidence/         # Command output, screenshots, links

This is on disk. It survives the chat transcript. It survives the harness swap. Another agent — or a human reviewer — can pick up the work months later by reading these files.

Core principles

• Context is king. Include all necessary information in the plan. The agent should not need to guess.
• Validation loops. Every plan has executable validation commands.
• Bounded scope. Each plan completes in one agent loop.
• Information dense. Exact file paths, function names, patterns from the codebase.
• Evidence over narration. Show what passed. Not “it worked.”
• Rollback ready. Define the last safe revert point before execution starts.

Where the harness comes in

PRP is the methodology. The harness is what runs it.

FIT’s primary engineering harness is Archon. Archon executes PRP through declarative DAG workflows — YAML files that specify nodes, dependencies, models, allowed tools, and gating conditions.

The fit-fix-issue-pro workflow is the heavyweight example. One YAML file, ten phases:

Phase 1  — extract issue number + fetch + classify
Phase 2  — web research (parallel)
Phase 3  — investigate (bugs) | plan (features) — gated by classification
Phase 4  — implement (Opus 4.6, fresh context)
Phase 5  — validate
Phase 6  — create draft PR using the repo's PR template
Phase 7  — review (always code review; conditional error/test/comment/docs)
Phase 8  — synthesize + self-fix all findings
Phase 9  — simplify changed code
Phase 10 — report back to the GitHub issue

Each phase has a fresh context window. Each phase has explicit allowed tools. Each phase has a model assignment (Haiku for classifiers, Opus for implementation). Conditional phases gate on the previous phase’s output. This is deterministic execution made visible.

That YAML — Archon/.archon/workflows/fit/fit-fix-issue-pro.yaml — is the single best artifact to show someone evaluating whether FIT actually runs governed agents or just talks about them.

Where to start a PRP

Three entry shapes, depending on scope.

Large feature

/prp-prd "describe the feature"        → creates PRD with phase table
/prp-plan path/to/feature.prd.md       → creates phase implementation plan
/prp-implement path/to/phase-1.plan.md → executes, validates, archives
repeat /prp-plan for each phase

Medium feature

/prp-plan "describe the change"  → direct to plan
/prp-implement path/to/plan.md

Bug fix

/prp-issue-investigate [issue-number]  → creates investigation artifact
/prp-issue-fix [issue-number]          → executes fix

Or run the full DAG through Archon:

fit pro #N    # heavyweight Opus path
fit #N        # lightweight Haiku-first path

What this looks like to a reviewer

A reviewer who wants to verify the “we build with agents” claim can do this:

1. Open fit-solutions/.agent/skills/prp.md — the methodology.
2. Open Archon/.archon/workflows/fit/fit-fix-issue-pro.yaml — the executable.
3. Open any .agent/prp/plans/completed/ directory in a FIT repo — the evidence trail.

Three files. No demo required. The system speaks for itself.

Repos with PRP enabled by default

forge · capture · n8n-insights · tools · fang-control · every solution template repo.

Why this loop ends differently

Normal dev loop ends with: Draft PR. This loop ends with: Draft PR + a codebase that’s smarter about being worked on.

The framing comes from Cole Medin’s Intent Engineering / PRD-PRP masterclass, adapted here to FIT’s PIV and AI Layer model.

Next

Operating Model — how PRP fits the wider FIT decision flow.