v0.4Open source · MIT · Codex, Claude Code, Antigravity

Progressive Change-Driven Development

Ship with AI agents.Without losingthe plot.

PCDD gives every change just enough process: a spec when it matters, a record that outlives the session, and a finish line you approve.

$ curl -fsSL https://pcdd.dev/install.sh | sh

or uv tool install pcdd · pipx install pcdd · Python 3.9+, zero dependencies

~/your-project
$ pcdd init
›_ pcdd · each change, just enough.
PCDD is ready.
Create  .pcdd/core.md
Create  AGENTS.md
Create  CLAUDE.md
Your own content is preserved.

$ pcdd new rate-limit
Change created: pcdd/changes/rate-limit.md
Define specs before implementing.

$ pcdd time status rate-limit
2/3 tasks completed · 2880 s recorded
Works with your agentCodexOpenAIClaude CodeAnthropicAntigravityGoogle

Other agents that read AGENTS.md can follow the core — not tested yet.

The problem

AI coding fails in two opposite ways.

Most teams swing between them. One fix gets a ten-page spec; the next risky migration gets a prompt and a prayer.

Too little process

Fast today. Lost tomorrow.

  • A new session forgets what was decided and why.
  • “Done” means it compiled, not that it works.
  • Risky changes get the same treatment as typos.
Too much process

Safe on paper. Skipped in practice.

  • A full spec for a one-line fix.
  • Ceremony burns context, tokens and patience.
  • So people stop following it — even when it matters.
PCDD

Process proportional to risk.

  • Small, clear work goes straight through.
  • Substantial work gets approved specs and a record.
  • Risky work gets independent review before commit.

Why it matters

Thursday morning.
New session.

You started a feature on Monday. Same request, same agent — the only difference is what it can read.

Without PCDD
Let’s continue the rate limiting work.
Sure! Could you remind me which approach we agreed on and what’s already done?
Is it finished?
Yes, it’s done! The feature is implemented.

You re-explain. You find the bug later.

With PCDD
Let’s continue the rate limiting work.
Resuming rate-limit: 2/3 tasks done, tests passing. Next step: you test the lockout after 5 attempts.
Is it finished?
The gate passed (make ready). It’s done when you accept it — here’s how to check.

It reads the record. You decide when it’s done.

How it works

Pick a change. Watch the process fit.

The agent assesses risk on its own terms, not by line count. Size alone never decides.

  1. Read context
  2. Approved specs (skipped)
  3. Tasks (skipped)
  4. Implement
  5. Checks
  6. Evidence (skipped)
  7. Independent review (skipped)
  8. Your acceptance

Fix a typo in the docs: Straight through.

Well-understood and bounded. The agent reads just enough context, makes the change and runs the checks. The diff is the record — no change document, no ceremony.

## RiskRisk: noneRecord: the diff itself
  1. Read context
  2. Approved specs
  3. Tasks
  4. Implement
  5. Checks
  6. Evidence
  7. Independent review (skipped)
  8. Your acceptance

Add rate limiting to login: Define, then build.

The agent proposes verifiable specs and waits for your approval. Tasks, test results and the next step are written to pcdd/changes/rate-limit.md, so any session can pick it up.

## RiskRisk: item 2 (security)Record: pcdd/changes/rate-limit.md
  1. Read context
  2. Approved specs
  3. Tasks
  4. Implement
  5. Checks
  6. Evidence
  7. Independent review
  8. Your acceptance

Migrate auth to a new provider: Review before commit.

Irreversible effects and security on the line. After the gate passes, an independent review verifies the work, and you approve from a summary you can actually understand.

## RiskRisk: items 1, 2, 3 (data, security, contracts)Record: change + independent review

Continuity

Close the laptop.
Keep the context.

Every substantial change lives in one Markdown file in your repo: specs, tasks, evidence and the exact next step. A fresh session — or a different agent — reads that, not your entire history.

Small starting context. Skills load only when needed. No external memory service.

Session 1 · CodexSession 2 · Claude Code
pcdd/changes/rate-limit.md2/3 tasks
## Specs
S1 — Limit login attempts per IP. Approved.

## Tasks
- [x] T1 (S1) Write the failing test
- [x] T2 (S1) Implement the limiter
- [ ] T3 (S1) Verify and accept

## Continuation
Next step: user tests lockout after 5 attempts.

Get started

Three steps.
Nothing new to learn.

No new app, no account, no config to write. You keep using your agent the way you already do.

  1. 1

    Install once

    $ curl -fsSL https://pcdd.dev/install.sh | sh

    One line. Installs uv if it’s missing. Python 3.9+, zero runtime dependencies.

  2. 2

    Add it to your project

    $ pcdd init

    Preview first with --dry-run. Your own content is preserved, and pcdd rollback undoes it.

  3. 3

    Just describe the change

    “Add rate limiting to the login endpoint.”

    Open Codex, Claude Code or Antigravity. The agent picks the right amount of process and asks only what it needs.

You stay in charge

The agent proposes.
You decide.

You approve the specs

Verifiable criteria, with your words quoted, before any code is written.

Evidence, not vibes

Test-first when the result is clear; otherwise the record says what remains unverified.

No surprise commits

Commits, pushes and publishing need your explicit go-ahead. No AI attribution added.

Yours, locally

Plain Markdown in your repo. Preview, update and roll back installs. No service, no lock-in.

Compare

Not the lightest.
The one that fits.

Same change, three approaches. See how much process each one asks for.

Fix a typo in the docs

SDDSpec-Driven
4 steps
  • Spec
  • Plan
  • Implement
  • Checks
ODDOrganic Driven
2 steps
  • Implement
  • Checks
PCDDProgressive Change-Driven
3 steps
  • Implement
  • Checks
  • Your acceptance

Spec-first workflows pay full ceremony for a one-line change. PCDD goes straight through — and you still check the result.

Shapes follow each approach’s organizing idea; real implementations vary. We haven’t measured time or tokens yet — when we do, we’ll publish the method with the numbers.

Add rate limiting to login

SDDSpec-Driven
5 steps
  • Spec
  • Plan
  • Tasks
  • Implement
  • Checks
ODDOrganic Driven
3 steps
  • Context notes
  • Implement
  • Checks
PCDDProgressive Change-Driven
6 steps
  • Approved specs
  • Tasks
  • Implement
  • Checks
  • Change record
  • Your acceptance

Here PCDD looks like SDD — plus a change record any session or agent can resume, and your sign-off at the end.

Shapes follow each approach’s organizing idea; real implementations vary. We haven’t measured time or tokens yet — when we do, we’ll publish the method with the numbers.

Migrate auth to a new provider

SDDSpec-Driven
5 steps
  • Spec
  • Plan
  • Tasks
  • Implement
  • Checks
ODDOrganic Driven
3 steps
  • Context notes
  • Implement
  • Checks
PCDDProgressive Change-Driven
7 steps
  • Approved specs
  • Tasks
  • Implement
  • Checks
  • Change record
  • Independent review
  • Your acceptance

When security and irreversible effects are on the line, PCDD adds an independent review after the gate, before anything is committed.

Shapes follow each approach’s organizing idea; real implementations vary. We haven’t measured time or tokens yet — when we do, we’ll publish the method with the numbers.

Each change,
just enough process.

Install in one line. Try it on your next change.

$ curl -fsSL https://pcdd.dev/install.sh | sh
Star on GitHub