PDD: The Last Programming Language™

Prompt files are source; code is generated output. PDD Cloud hosts the prompt-native workflow for teams that want to regenerate software from durable intent instead of accumulating manual patches.

Read the Whitepaper Get Started with PDD CLI

// The thesis

The Paradigm Shift: Prompt Files as Source

Traditional software development faces a significant challenge: the overwhelming cost of maintenance, often consuming 80-90% of total development costs. Modifying existing, patched code is like renovating an old house – complex and expensive.

Prompt-Driven Development (PDD) proposes a solution: instead of treating generated code as the primary artifact, PDD elevates prompt files to this central role. The core idea is to maintain and evolve prompt source, regenerating the code as needed, rather than continuously patching the code itself.

Developers focus more on intent, logic, and system design. Prompts become the high-level, authoritative description from which code is derived.

Development model comparison

Loading diagram...

Patching Model

Documentation drifts away from implementation.
Each patch adds more context and coupling.
Complexity accumulates inside the codebase.

PDD Model

Prompts remain the durable source artifact.
Code, examples, and tests regenerate from intent.
Implementation learnings flow back into prompts.

// Why PDD

Why Prompt-Driven Development?

Reduced Maintenance Cost

Regenerate code from updated prompts, avoiding 'rat's nest' complexity and technical debt from repeated patching.

Increased Developer Efficiency

Operate at a higher abstraction level. PDD's batch nature frees developers from constant AI supervision.

Significant Cost Savings (LLM Usage)

Modular, token-efficient prompts and batch processing API discounts lead to lower LLM spend.

Enhanced Control & Consistency

Directed, reproducible generation from version-controlled prompts, unlike unpredictable chatbot interactions.

Improved Collaboration & Accessibility

Natural language prompts serve as a common language for technical and non-technical stakeholders.

Better Scalability & Complexity Management

PDD's directed, modular approach offers more control for large, evolving systems.

// How it works

The PDD Workflow: A Synchronized Cycle

PDD utilizes a batch-oriented, synchronized cycle, contrasting with the constant supervision model of interactive patching:

Define: Start with a requirement (e.g., from a PRD) and break it down into a specific prompt for a code module. Use `auto-deps` to find and include necessary context.
Generate: Use `pdd generate` to create the code module from the prompt.
Example: Use `pdd example` to create a minimal usage example (the interface).
Verify (Initial): Use `pdd verify` or `pdd crash` to ensure the example/code runs and aligns with the prompt's intent, fixing basic issues iteratively.
Test: Use `pdd test` to generate unit tests for the code module.
Fix: Use `pdd fix` along with the generated tests to identify and correct bugs.
Update & Back-propagate: Use `pdd update` to synchronize changes back to the prompt and architectural specs.

The fundamental unit is often the prompt and its generated code, example, and test file – all kept in sync. If a prompt is too complex, `pdd split` helps create manageable units.

Define

Turn the requirement into a precise prompt and gather context.

Generate

Create code and an executable example from the prompt.

Verify

Check runtime behavior against the intended outcome.

Test & Fix

Generate tests, repair failures, and preserve regressions.

Update

Sync implementation learnings back into prompt source.

Interactive PDD workflow

Loading diagram...

// Principles

Core Principles of PDD

Prompts as Source of Truth

Regenerative Development

Intent Preservation

Modularity

Synchronization

Batch-Oriented Workflow

// Get started

Install PDD CLI

Get started with PDD by installing the CLI tool. The recommended method uses `uv`:

>curl -LsSf https://astral.sh/uv/install.sh | sh

>uv tool install pdd-cli

View Full Documentation (README)

// PDD Cloud

Hosted Prompt-Native Development

PDD Cloud brings the prompt-first workflow into a shared, browser-based surface for teams that want GitHub-connected automation, visible run state, and durable prompt/code synchronization.

Browser-Based PDD

Run prompt-native workflows from a hosted interface while keeping prompts, generated code, examples, and tests visible as one system.

GitHub-Connected Automation

Connect issues, pull requests, and review loops so implementation work stays anchored to tracked intent instead of ad-hoc chat.

Durable Run Context

Preserve the operational context around prompt updates, generated outputs, checks, and fixes so teams can understand what changed.